@receiz/sdk 97.1.0 → 97.3.0

package/dist/index.js

@@ -1,12 +1,46 @@
 import { buildReceizIdContinueRequest, createReceizIdIdentity, projectReceizIdentityAccount, readReceizIdentityArtifact, signReceizIdentityLoginProof, verifyReceizIdentityLoginProof, } from "./identity.js";
 export * from "./identity.js";
-export const RECEIZ_SDK_VERSION = "97.1.0";
+export const RECEIZ_SDK_VERSION = "97.3.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_OIDC_SCOPES_BY_RAIL = {
+    identity: ["openid", "profile", "email"],
+    wallet: ["receiz:wallet.read", "receiz:wallet.transfer"],
+    payments: ["receiz:payments.read", "receiz:payments.create"],
+    proofStore: ["receiz:record", "receiz:seal", "receiz:verify"],
+    media: ["receiz:record"],
+    domains: ["receiz:record"],
+    twin: ["receiz:twin.read", "receiz:twin.write"],
+    commerce: ["receiz:payments.read", "receiz:payments.create", "receiz:wallet.read", "receiz:record"],
+    rewards: ["receiz:record", "receiz:wallet.read"],
+    customers: ["openid", "profile", "email", "offline_access", "receiz:wallet.read", "receiz:payments.read"],
+    merchants: ["openid", "profile", "email", "offline_access", "receiz:record", "receiz:wallet.read", "receiz:payments.read", "receiz:payments.create"],
+    events: ["receiz:record"],
+    search: ["receiz:record"],
+    permissions: ["receiz:record"],
+    jobs: ["receiz:record"],
+    audit: ["receiz:record"],
+    risk: ["receiz:record"],
+    compliance: ["receiz:record"],
+    portability: ["receiz:record"],
+    notifications: ["receiz:record"],
+    offline: ["receiz:record"],
+    releases: ["receiz:record"],
+    appState: ["receiz:record"],
+    publicStore: ["receiz:record"],
+};
+export function receizOidcScopesForRails(...rails) {
+    const scopes = new Set();
+    for (const rail of rails) {
+        for (const scope of RECEIZ_OIDC_SCOPES_BY_RAIL[rail] ?? [])
+            scopes.add(scope);
+    }
+    return [...scopes];
+}
 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",
@@ -268,6 +302,19 @@ function headersWithIdempotency(headers, 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))
@@ -577,6 +624,12 @@ export class ReceizClient {
         extractData: extractReceizAppStateData,
         restoreProjection: restoreReceizAppStateProjection,
     };
+    publicStore = {
+        publish: (input, options = {}) => this.publishPublicStore(input, options),
+        resolve: (input) => this.resolvePublicStore(input),
+        createRecord: createReceizPublicStoreStateRecord,
+        scopes: RECEIZ_OIDC_SCOPES_BY_RAIL.publicStore,
+    };
     sports = {
         conformance: () => this.sportsConformance(),
         conformanceHistory: () => this.request("/api/game/sports/conformance/history"),
@@ -584,10 +637,16 @@ export class ReceizClient {
         badge: () => this.request("/api/game/sports/conformance/badge"),
         eventProofUrl: (eventProofId) => `${this.baseUrl}/game/sports/event/${encodePathSegment(eventProofId)}`,
         assertCardManifest: assertReceizSportsCardManifest,
+        resolveCardMemory: (input) => this.resolveLocalFirstSurface("sports.card_memory", input),
+        resolvePitchDayProof: (input) => this.resolveLocalFirstSurface("sports.pitch_day_proof", input),
     };
     wallet = {
         publicLedger: (query = {}) => this.publicWalletLedger(query),
         actionLedger: (query = {}) => this.request(appendQuery("/api/ledger/actions/public", query)),
+        resolveLedger: (input) => this.resolveLocalFirstSurface("wallet.ledger", input),
+    };
+    profile = {
+        resolveLocalFirst: (input) => this.resolveLocalFirstSurface("profile", input),
     };
     world = {
         publicSnapshot: () => this.request("/api/world/public"),
@@ -676,9 +735,61 @@ export class ReceizClient {
         }),
         bootstrap: (username) => this.request(`/api/connect/login/bootstrap/${encodePathSegment(username)}`),
         authorizeUrl: (options) => this.authorizeUrl(options),
+        ensureTenantSession: (input) => this.ensureTenantSession(input),
+    };
+    customers = {
+        bootstrapSession: (body, options = {}) => this.bootstrapCustomerSession(body, options),
+        bootstrap: (body, options = {}) => this.bootstrapCustomerSession(body, options),
+        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 }),
@@ -686,6 +797,7 @@ export class ReceizClient {
     };
     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 = {
@@ -708,6 +820,9 @@ export class ReceizClient {
     };
     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 }),
@@ -718,6 +833,56 @@ export class ReceizClient {
             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,
@@ -775,6 +940,16 @@ export class ReceizClient {
         createLocalStorage: createReceizLocalStorageProofMemoryStorage,
         assertSnapshot: assertReceizProofRegisterSnapshot,
         additionsQuery: receizProofMemoryAdditionsQuery,
+        syncAdditions: (input) => this.syncProofMemoryAdditions(input),
+    };
+    runtime = {
+        localFirst: (input = {}) => this.runtimeLocalFirst(input),
+    };
+    offline = {
+        createQueue: createReceizOfflineProofQueue,
+        createInMemoryStorage: createReceizInMemoryOfflineProofQueueStorage,
+        createLocalStorage: createReceizLocalStorageOfflineProofQueueStorage,
+        assertSnapshot: assertReceizOfflineProofQueueSnapshot,
     };
     constructor(options = {}) {
         this.baseUrl = trimTrailingSlash(options.baseUrl ?? RECEIZ_DEFAULT_BASE_URL);
@@ -831,12 +1006,14 @@ export class ReceizClient {
         const tenantHost = options.tenantHost ? normalizeReceizHost(options.tenantHost) : undefined;
         const scopes = options.scopes ?? [];
         const delegatedAvailable = Boolean(this.accessToken);
-        const configured = (available, reason) => ({
+        const configured = (available, reason, requirements) => ({
             available,
             status: available ? "available" : "missing",
             ...(reason ? { reason } : {}),
             ...(!available ? { fixUrl: `${this.baseUrl}/developers` } : {}),
+            ...(requirements ? { requirements } : {}),
         });
+        const tenantAndBearer = { tenantHost: true, accessToken: true };
         return {
             ok: true,
             schema: "receiz.sdk.capabilities.v1",
@@ -853,10 +1030,19 @@ export class ReceizClient {
                 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."),
+                customers: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for customer sessions.", tenantAndBearer),
+                merchants: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for merchant rails.", tenantAndBearer),
                 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."),
             },
         };
     }
@@ -1011,6 +1197,167 @@ export class ReceizClient {
         }
         throw new ReceizValidationError("receiz.appState.resolve", ["id, url, host, tenantHost, namespace, creatorReceizId, or receizId is required"]);
     }
+    async publishPublicStore(input, options = {}) {
+        const tenantHost = normalizeReceizHost(input.tenantHost);
+        const sourceUrl = input.sourceUrl ?? receizAppStateUrlFromHost(tenantHost);
+        const publicStoreRecordInput = {
+            sourceUrl,
+            externalCreatorId: input.merchantReceizId,
+            title: input.title ?? `${tenantHost} storefront`,
+            namespace: input.namespace ?? tenantHost,
+            state: input.projectionState ?? "published",
+            schema: input.schema ?? RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA,
+            platform: input.platform ?? "Receiz.app Commerce Cloud",
+            record: input.record ?? input.state,
+            data: input.data ?? {
+                storeStateRecord: input.state,
+                tenantHost,
+                merchantReceizId: input.merchantReceizId,
+            },
+        };
+        if (input.id)
+            publicStoreRecordInput.id = input.id;
+        const record = createReceizPublicStoreStateRecord(publicStoreRecordInput);
+        const feedOptions = {
+            schema: RECEIZ_PUBLIC_STORE_STATE_FEED_SCHEMA,
+            externalCreatorId: input.merchantReceizId,
+        };
+        if (record.namespace)
+            feedOptions.namespace = record.namespace;
+        const publishOptions = {};
+        const idempotencyKey = options.idempotencyKey ?? input.idempotencyKey;
+        if (idempotencyKey)
+            publishOptions.idempotencyKey = idempotencyKey;
+        return this.publishAppState(createReceizAppStateFeed([record], feedOptions), publishOptions);
+    }
+    async resolvePublicStore(input) {
+        const options = {
+            schema: RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA,
+            state: "published",
+            requiredDataKey: "storeStateRecord",
+        };
+        let restored;
+        if (input.id) {
+            restored = await this.restoreAppStateById(input.id, options);
+        }
+        else if (input.url) {
+            restored = await this.restoreAppStateByUrl(input.url, options);
+        }
+        else {
+            const host = input.host ?? input.tenantHost;
+            if (!host)
+                throw new ReceizValidationError("receiz.publicStore.resolve", ["host, tenantHost, url, or id is required"]);
+            restored = await this.restoreAppStateByHost(host, options);
+        }
+        const storeStateRecord = restored.data?.storeStateRecord ?? null;
+        return {
+            ...restored,
+            state: storeStateRecord,
+            storeStateRecord,
+        };
+    }
+    async syncProofMemoryAdditions(input) {
+        const knownHead = input.memory.knownHead(input.limit);
+        const batch = await input.fetchAdditions(knownHead);
+        let admitted = 0;
+        for (const addition of proofMemoryAdditionValues(batch)) {
+            admitProofMemoryAddition(input.memory, addition);
+            admitted += 1;
+        }
+        await input.memory.flush();
+        return {
+            ok: true,
+            schema: "receiz.sdk.proof_memory.sync.v1",
+            knownHead,
+            admitted,
+            snapshot: input.memory.snapshot(),
+        };
+    }
+    async resolveLocalFirstSurface(surface, input) {
+        const local = input.local ?? null;
+        const snapshot = input.memory?.snapshot() ?? null;
+        const knownHead = input.memory ? input.memory.knownHead(input.limit) : null;
+        const sync = input.memory && input.sync
+            ? this.syncProofMemoryAdditions({
+                memory: input.memory,
+                fetchAdditions: input.sync,
+                ...(input.limit === undefined ? {} : { limit: input.limit }),
+            })
+            : null;
+        if (local !== null) {
+            return {
+                ok: true,
+                schema: "receiz.sdk.local_first.v1",
+                surface,
+                source: "local",
+                value: local,
+                local,
+                knownHead,
+                snapshot,
+                sync,
+            };
+        }
+        const remote = input.remote ? await input.remote() : null;
+        return {
+            ok: true,
+            schema: "receiz.sdk.local_first.v1",
+            surface,
+            source: remote !== null ? "remote" : "empty",
+            value: remote,
+            local,
+            knownHead,
+            snapshot,
+            sync,
+        };
+    }
+    async runtimeLocalFirst(input = {}) {
+        const memoryOptions = {
+            ...(input.ownerId === undefined ? {} : { ownerId: input.ownerId }),
+            ...(input.storage === undefined ? {} : { storage: input.storage }),
+        };
+        const memory = await createReceizProofMemory(memoryOptions);
+        for (const proofObject of input.seed ?? [])
+            memory.admit(proofObject);
+        await memory.flush();
+        const knownHead = memory.knownHead(input.limit);
+        const sync = input.sync
+            ? this.syncProofMemoryAdditions({
+                memory,
+                fetchAdditions: input.sync,
+                ...(input.limit === undefined ? {} : { limit: input.limit }),
+            })
+            : null;
+        return {
+            ok: true,
+            schema: "receiz.sdk.runtime.local_first.v1",
+            memory,
+            snapshot: memory.snapshot(),
+            knownHead,
+            sync,
+        };
+    }
+    async bootstrapCustomerSession(body, options = {}) {
+        const tenantHost = normalizeReceizHost(body.tenantHost);
+        const requestBody = {
+            ...body,
+            tenantHost,
+        };
+        const session = await this.delegatedWrite("/api/connect/customers/session", requestBody, options);
+        const wallet = body.includeWallet === false ? null : await this.delegated("/api/connect/wallet/me");
+        const customer = body.includeCustomer === false ? null : await this.delegatedWrite("/api/connect/customers/portal", requestBody);
+        const permissions = body.includePermissions === false
+            ? null
+            : await this.delegated(appendQuery("/api/connect/permissions/roles", { tenantHost }));
+        return {
+            ok: true,
+            schema: "receiz.sdk.customer_session.bootstrap.v1",
+            tenantHost,
+            session,
+            wallet,
+            customer,
+            permissions,
+        };
+    }
     async oneClickCheckout(body) {
         const tenantHost = normalizeReceizHost(body.tenantHost);
         const totalUsdCents = usdToCents(body.amountUsd);
@@ -1123,6 +1470,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");
@@ -1224,6 +1579,48 @@ export class ReceizClient {
             url.searchParams.set("login_hint", options.usernameHint);
         return url.toString();
     }
+    ensureTenantSession(input) {
+        const tenantHost = normalizeReceizHost(input.tenantHost);
+        const fallback = input.fallback ?? "artifact_upload";
+        const scope = Array.isArray(input.scope)
+            ? input.scope
+            : typeof input.scope === "string" && input.scope.trim()
+                ? input.scope.trim().split(/\s+/)
+                : receizOidcScopesForRails("identity", "customers", "publicStore");
+        let url;
+        if (input.clientId && input.codeChallenge) {
+            const authorizeOptions = {
+                clientId: input.clientId,
+                redirectUri: input.redirectUri ?? input.returnTo ?? `${this.baseUrl}/developers/connect`,
+                codeChallenge: input.codeChallenge,
+                scope,
+            };
+            if (input.codeChallengeMethod)
+                authorizeOptions.codeChallengeMethod = input.codeChallengeMethod;
+            if (input.state)
+                authorizeOptions.state = input.state;
+            if (input.usernameHint)
+                authorizeOptions.usernameHint = input.usernameHint;
+            url = new URL(this.authorizeUrl(authorizeOptions));
+        }
+        else {
+            url = new URL(`${this.baseUrl}/signin`);
+            url.searchParams.set("lane", "connect");
+        }
+        url.searchParams.set("tenantHost", tenantHost);
+        if (input.returnTo)
+            url.searchParams.set("returnTo", input.returnTo);
+        url.searchParams.set("fallback", fallback);
+        return {
+            ok: true,
+            schema: "receiz.sdk.identity.tenant_session.ensure.v1",
+            tenantHost,
+            fallback,
+            url: url.toString(),
+            scope,
+            ...(input.returnTo ? { returnTo: input.returnTo } : {}),
+        };
+    }
     async delegatedVerifyArtifact(file) {
         const form = new FormData();
         form.set("file", file);
@@ -1705,6 +2102,33 @@ function errorDetail(error) {
         return { name: error.name, message: error.message };
     return { message: String(error) };
 }
+function isProofRegisterEntry(value) {
+    return isRecord(value) && typeof value.id === "string" && typeof value.kind === "string" && isRecord(value.payload);
+}
+function proofMemoryAdditionValues(batch) {
+    if (Array.isArray(batch))
+        return batch;
+    if (isProofRegisterEntry(batch))
+        return [batch];
+    const out = [];
+    for (const key of ["entries", "additions", "proofs", "records"]) {
+        const value = batch[key];
+        if (Array.isArray(value))
+            out.push(...value);
+    }
+    return out;
+}
+function admitProofMemoryAddition(memory, addition) {
+    if (isProofRegisterEntry(addition)) {
+        memory.append(addition);
+        return;
+    }
+    if (isRecord(addition) && isProofRegisterEntry(addition.entry)) {
+        memory.append(addition.entry);
+        return;
+    }
+    memory.admit(addition);
+}
 export class ReceizProofRegister {
     ownerId;
     createdAt;
@@ -1957,6 +2381,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;