@openlup/platform 0.19.0 → 0.21.0

package/dist/payments/verifiedEvidenceProjection.js

@@ -0,0 +1,166 @@
+/** New boundary module: verified adapter envelopes into the unchanged donor carrier.
+ * Original bytes go only to verification. Store adapter-redacted audit facts plus
+ * nested normalized evidence; typed facts override overlapping reader keys.
+ * Neither audit shape nor receipt time changes adapter identity/fingerprint.
+ * Incomplete refunds are ingested and acknowledged, but require-evidence prevents apply.
+ */
+export function projectVerifiedEvidence(evidence, input, policy, methodOwner) {
+    const payload = auditPayload(evidence);
+    const base = {
+        provider: evidence.provider, providerEventId: evidence.providerEventId,
+        occurredAt: input.receivedAt, rawPayload: payload,
+        paymentIntentId: evidence.intentRef,
+    };
+    switch (evidence.kind) {
+        case "money": {
+            // The donor treats absent money as unasserted and skips parity checks.
+            // Settling adapter evidence must instead use its existing mismatch refusal.
+            if ((evidence.outcome === "succeeded" || evidence.outcome === "refunded" || evidence.outcome === "disputed")
+                && (evidence.money === null || !Number.isSafeInteger(evidence.money.amountMinor)
+                    || evidence.money.amountMinor <= 0 || !evidence.money.currency.trim())) {
+                throw new Error("payment_control_result_amount_mismatch");
+            }
+            const reversal = evidence.refund;
+            const refundKind = evidence.outcome === "refunded"
+                ? (reversal ? projectRefund(reversal, evidence) : null) ?? (policy === "legacy-assume-full" ? "full" : null)
+                : undefined;
+            return {
+                ...base, eventType: moneyEvent(evidence.outcome, refundKind ? reversal : undefined),
+                providerPaymentId: evidence.providerPaymentRef, paymentAttemptId: evidence.attemptRef,
+                amountMinor: evidence.money?.amountMinor ?? null, currency: evidence.money?.currency ?? null,
+                refundKind,
+            };
+        }
+        case "method":
+            return {
+                ...base, eventType: methodEvent(evidence.outcome),
+                // Pinned donor normalizer :59 calls resolveLinkagePaymentId :146–154:
+                // setup/method objects use their own object id as the carrier reference.
+                providerPaymentId: evidence.setupRef ?? evidence.methodRef,
+                methodLifecycle: lifecycle(evidence.methodLifecycle),
+                ...(evidence.reusableMethod && methodOwner ? { reusableMethod: {
+                        clientId: methodOwner.clientId, subscriptionId: methodOwner.subscriptionId,
+                        providerCustomerRef: evidence.reusableMethod.providerCustomerRef,
+                        providerMethodRef: evidence.reusableMethod.providerMethodRef,
+                        providerMandateRef: evidence.reusableMethod.providerMandateRef,
+                        methodKind: evidence.reusableMethod.methodKind, status: evidence.reusableMethod.status,
+                    } } : {}),
+            };
+    }
+    return assertNever(evidence);
+}
+function moneyEvent(outcome, refund) {
+    switch (outcome) {
+        case "succeeded": return "payment.succeeded";
+        case "failed": return "payment.failed";
+        case "pending": return "payment.requires_action";
+        case "refunded": return refund?.kind === "full-reversal" && refund.reason === "chargeback" ? "payment.disputed" : "payment.refunded";
+        case "disputed": return "payment.disputed";
+    }
+    return assertNever(outcome);
+}
+function methodEvent(outcome) {
+    switch (outcome) {
+        case "registered":
+        case "updated": return "setup.succeeded";
+        case "revoked":
+        case "expired":
+        case "suspended":
+        case "failed": return "setup.failed";
+        case "requires-action": return "setup.requires_action";
+    }
+    return assertNever(outcome);
+}
+function projectRefund(refund, evidence) {
+    const original = refund.originalPaymentMoney;
+    if (!refund.operationId?.trim() || !evidence.providerPaymentRef.trim()
+        || !Number.isSafeInteger(original?.amountMinor) || original.amountMinor <= 0
+        || !original.currency?.trim() || !evidence.money
+        || evidence.money.amountMinor !== original.amountMinor || evidence.money.currency !== original.currency) {
+        return null;
+    }
+    switch (refund.kind) {
+        case "full-reversal": return "full";
+        case "cumulative-snapshot":
+        case "event-delta": {
+            const money = refund.refundedMoney;
+            if (!Number.isSafeInteger(money?.amountMinor) || money.amountMinor <= 0
+                || money.amountMinor > original.amountMinor || money.currency !== original.currency) {
+                return null;
+            }
+            return money.amountMinor < original.amountMinor ? "partial" : "full";
+        }
+    }
+    return assertNever(refund);
+}
+function assertNever(value) {
+    throw new Error(`payment_evidence_unmapped:${String(value)}`);
+}
+function auditPayload(evidence) {
+    // Explicit typed fields only: unknown envelope properties never enter storage.
+    const normalized = {
+        provider: evidence.provider, providerEventId: evidence.providerEventId,
+        fingerprint: evidence.fingerprint,
+        providerOccurredAt: evidence.providerOccurredAt, kind: evidence.kind,
+        intentRef: evidence.intentRef, outcome: evidence.outcome,
+        ...(evidence.kind === "money" ? {
+            providerPaymentRef: evidence.providerPaymentRef, attemptRef: evidence.attemptRef,
+            money: evidence.money && money(evidence.money),
+            refusal: evidence.refusal && { code: evidence.refusal.code,
+                hints: [...evidence.refusal.hints], adviceCode: evidence.refusal.adviceCode },
+            refund: evidence.refund && refund(evidence.refund),
+        } : {
+            methodRef: evidence.methodRef, setupRef: evidence.setupRef,
+            methodLifecycle: lifecycle(evidence.methodLifecycle),
+            reusableMethod: evidence.reusableMethod && {
+                providerCustomerRef: evidence.reusableMethod.providerCustomerRef,
+                providerMethodRef: evidence.reusableMethod.providerMethodRef,
+                providerMandateRef: evidence.reusableMethod.providerMandateRef,
+                methodKind: evidence.reusableMethod.methodKind, status: evidence.reusableMethod.status,
+            },
+        }),
+    };
+    const payload = { ...evidence.providerAuditPayload };
+    if (evidence.kind === "money") {
+        // Host readers use the provider object reference and original payment money.
+        payload.providerPaymentId = evidence.providerPaymentRef;
+        payload.amountMinor = evidence.money?.amountMinor ?? null;
+        payload.currency = evidence.money?.currency ?? null;
+        // Snapshot reader namespaces are adapter-owned. Their charge identity has no
+        // typed home; their cumulative amount must come from the typed observation.
+        for (const [key, value] of Object.entries(payload)) {
+            if (value && typeof value === "object" && !Array.isArray(value) && "chargeId" in value) {
+                payload[key] = { ...value, amountRefundedMinor: evidence.refund?.kind === "cumulative-snapshot"
+                        ? evidence.refund.refundedMoney?.amountMinor ?? null : null };
+            }
+        }
+        const failure = payload.failureEvidence;
+        if (failure && typeof failure === "object" && !Array.isArray(failure)) {
+            payload.failureEvidence = { ...failure, providerPaymentId: evidence.providerPaymentRef,
+                code: evidence.refusal?.code ?? null, adviceCode: evidence.refusal?.adviceCode ?? null };
+        }
+    }
+    payload.openlupEvidence = normalized;
+    return payload;
+}
+function money(value) {
+    return { amountMinor: value.amountMinor, currency: value.currency };
+}
+function refund(value) {
+    const base = { operationId: value.operationId, originalPaymentMoney: value.originalPaymentMoney && money(value.originalPaymentMoney) };
+    switch (value.kind) {
+        case "full-reversal": return { ...base, kind: value.kind, reason: value.reason };
+        case "cumulative-snapshot":
+        case "event-delta":
+            return { ...base, kind: value.kind, refundedMoney: value.refundedMoney && money(value.refundedMoney) };
+    }
+    return assertNever(value);
+}
+function lifecycle(value) {
+    return value && { kind: value.kind, providerKind: value.providerKind,
+        providerMethodRef: value.providerMethodRef, providerEventId: value.providerEventId,
+        occurredAt: value.occurredAt, replacement: value.replacement && {
+            schemeLabel: value.replacement.schemeLabel, lastDigits: value.replacement.lastDigits,
+            expiresAt: value.replacement.expiresAt,
+        } };
+}

package/dist/payments/verifiedIngress.d.ts

@@ -0,0 +1,119 @@
+import type { PaymentIngressPort, PaymentVerifyNormalizePort, RefundEvidencePolicy, VerifiedMethodEvidence } from "./contracts/evidence.js";
+declare const PAYMENT_WEBHOOK_EVENT_TYPES: readonly ["payment.succeeded", "payment.failed", "payment.refunded", "payment.requires_action", "payment.disputed", "setup.succeeded", "setup.failed", "setup.requires_action"];
+type PaymentWebhookEventType = (typeof PAYMENT_WEBHOOK_EVENT_TYPES)[number];
+export type ProviderPaymentWebhookKind = PaymentWebhookEventType;
+export interface NormalizedProviderPaymentWebhook {
+    provider: string;
+    providerEventId: string;
+    eventType: ProviderPaymentWebhookKind;
+    providerPaymentId: string;
+    paymentIntentId?: string | null;
+    paymentAttemptId?: string | null;
+    amountMinor?: number | null;
+    currency?: string | null;
+    occurredAt: string;
+    refundKind?: "full" | "partial" | null;
+    rawPayload: Record<string, unknown>;
+    reusableMethod?: {
+        clientId: string;
+        subscriptionId?: string | null;
+        providerCustomerRef?: string | null;
+        providerMethodRef: string;
+        providerMandateRef?: string | null;
+        methodKind: string;
+        status: "pending_verification" | "active" | "inactive" | "expired" | "revoked";
+        consentSnapshot?: Record<string, unknown>;
+    } | null;
+}
+export interface PaymentWebhookControlPort {
+    ingestPaymentEvent(input: NormalizedProviderPaymentWebhook): Promise<{
+        paymentEventId: string;
+        paymentIntentId: string | null;
+        paymentAttemptId: string | null;
+        replayed: boolean;
+        occurredAt?: string;
+    }>;
+    applyPaymentResult?(input: {
+        idempotencyKey: string;
+        paymentIntentId: string;
+        paymentEventId: string;
+        resultStatus: "succeeded" | "failed" | "refunded" | "partially_refunded" | "disputed";
+        occurredAt: string;
+        failureReason: string | null;
+    }): Promise<{
+        replayed: boolean;
+    }>;
+    confirmSubscriptionActivation?(input: {
+        idempotencyKey: string;
+        paymentIntentId: string;
+        occurredAt: string;
+        methodRef: string | null;
+        methodKind: string | null;
+    }): Promise<{
+        confirmed: boolean;
+        status: string | null;
+    }>;
+    recoverPaidSubscriptionActivationWithCard?(input: {
+        idempotencyKey: string;
+        subscriptionId: string;
+        paymentMethodRef: string;
+        occurredAt: string;
+    }): Promise<{
+        recovered: boolean;
+        replayed: boolean;
+        reason: string | null;
+    }>;
+    /**
+     * Closes the ledger row of a `setup.*` event once the full setup pipeline
+     * resolved. Setup events carry no money result, so applyPaymentResult (the
+     * only other processed_at writer) never runs for them.
+     */
+    markSetupEventProcessed?(input: {
+        paymentEventId: string;
+    }): Promise<{
+        updated: boolean;
+    }>;
+}
+export interface PaymentWebhookMethodRefPort {
+    upsertFromWebhook(input: NormalizedProviderPaymentWebhook): Promise<{
+        replayed: boolean;
+    }>;
+}
+export type PaymentWebhookAfterProcessed = (input: {
+    event: NormalizedProviderPaymentWebhook;
+    ingested: {
+        paymentEventId: string;
+        paymentIntentId: string | null;
+        paymentAttemptId: string | null;
+        replayed: boolean;
+    };
+    resultStatus: "succeeded" | "failed" | "refunded" | "partially_refunded" | "disputed" | null;
+}) => Promise<void>;
+export interface PaymentWebhookProcessingPorts {
+    paymentControlPort: PaymentWebhookControlPort;
+    methodRefPort?: PaymentWebhookMethodRefPort;
+    afterProcessed?: PaymentWebhookAfterProcessed;
+}
+type OperationalEventRecorder = (event: {
+    name: string;
+    domain: string;
+    surface: string;
+    details: Record<string, unknown>;
+}) => void;
+/** Verified ingress boundary; persistence and transport response writing belong to the host. */
+export declare function createVerifiedPaymentIngress({ provider, verifyPort, paymentControlPort, methodRefPort, afterProcessed, createPorts, resolveMethodOwner, refundEvidencePolicy, operationalEvents, }: {
+    provider: string;
+    verifyPort: PaymentVerifyNormalizePort;
+    paymentControlPort: PaymentWebhookControlPort;
+    methodRefPort?: PaymentWebhookMethodRefPort;
+    afterProcessed?: PaymentWebhookAfterProcessed;
+    createPorts?: (event: NormalizedProviderPaymentWebhook) => PaymentWebhookProcessingPorts | Promise<PaymentWebhookProcessingPorts>;
+    /** Host-owned identity; adapter metadata cannot supply client/subscription authority. */
+    resolveMethodOwner?: (evidence: VerifiedMethodEvidence) => Promise<{
+        clientId: string;
+        subscriptionId?: string | null;
+    } | null>;
+    refundEvidencePolicy?: RefundEvidencePolicy;
+    operationalEvents?: OperationalEventRecorder;
+}): PaymentIngressPort;
+export {};

package/dist/payments/verifiedIngress.js

@@ -0,0 +1,220 @@
+import { projectVerifiedEvidence } from "./verifiedEvidenceProjection.js";
+const PAYMENT_WEBHOOK_EVENT_TYPES = [
+    "payment.succeeded",
+    "payment.failed",
+    "payment.refunded",
+    "payment.requires_action",
+    "payment.disputed",
+    "setup.succeeded",
+    "setup.failed",
+    "setup.requires_action",
+];
+/** Verified ingress boundary; persistence and transport response writing belong to the host. */
+export function createVerifiedPaymentIngress({ provider, verifyPort, paymentControlPort, methodRefPort, afterProcessed, createPorts, resolveMethodOwner, refundEvidencePolicy = "require-evidence", operationalEvents = () => { }, }) {
+    return { async receive(input) {
+            let evidence;
+            try {
+                evidence = await verifyPort.verifyAndNormalize(input);
+            }
+            catch {
+                return { status: 400, data: { error: "Invalid provider webhook signature" } };
+            }
+            if (evidence.kind === "refusal") {
+                return evidence.reason === "unsupported-event"
+                    ? { status: 200, data: { provider, acknowledged: true, skipped: "unsupported_event" } }
+                    : { status: 400, data: { error: "Invalid provider webhook signature" } };
+            }
+            const verifiedEvidence = evidence;
+            let event;
+            const res = { status: 503, data: {} };
+            const sendSuccess = (target, data) => { target.status = 200; target.data = data; };
+            const sendBffError = (target, code, error) => {
+                target.status = code === "BAD_REQUEST" ? 400 : code === "CONFLICT" ? 409 : 503;
+                target.data = { error };
+            };
+            await processEvent();
+            return res;
+            async function processEvent() {
+                try {
+                    try {
+                        event = projectVerifiedEvidence(verifiedEvidence, input, refundEvidencePolicy);
+                    }
+                    catch (error) {
+                        if (error instanceof Error && error.message === "payment_control_result_amount_mismatch")
+                            throw error;
+                        sendBffError(res, "BAD_REQUEST", "Invalid provider webhook evidence");
+                        return;
+                    }
+                    if (event.provider !== provider) {
+                        sendBffError(res, "BAD_REQUEST", "Provider webhook route mismatch");
+                        return;
+                    }
+                    if (verifiedEvidence.kind === "method" && verifiedEvidence.reusableMethod && resolveMethodOwner) {
+                        const owner = await resolveMethodOwner(verifiedEvidence);
+                        event = projectVerifiedEvidence(verifiedEvidence, input, refundEvidencePolicy, owner ?? undefined);
+                    }
+                    const ports = createPorts
+                        ? await createPorts(event)
+                        : { paymentControlPort: paymentControlPort, methodRefPort, afterProcessed };
+                    if (!ports.paymentControlPort)
+                        throw new Error("Provider webhook port unavailable");
+                    const ingested = await ports.paymentControlPort.ingestPaymentEvent(event);
+                    if (ingested.occurredAt)
+                        event = { ...event, occurredAt: ingested.occurredAt };
+                    const resultStatus = mapResultStatus(event, refundEvidencePolicy);
+                    if (resultStatus && ingested.paymentIntentId && ports.paymentControlPort.applyPaymentResult) {
+                        await ports.paymentControlPort.applyPaymentResult({
+                            idempotencyKey: `provider-webhook:${provider}:${event.providerEventId}:apply`,
+                            paymentIntentId: ingested.paymentIntentId,
+                            paymentEventId: ingested.paymentEventId,
+                            resultStatus,
+                            occurredAt: event.occurredAt,
+                            failureReason: event.eventType === "payment.failed" ? "provider_webhook_failed" : null,
+                        });
+                    }
+                    else if (isMoneyMoved(resultStatus) && !ingested.paymentIntentId && !ingested.replayed) {
+                        // Operator policy: payments should only originate at the storefront
+                        // checkout. A money-moved provider event (succeeded / refunded /
+                        // disputed) that matched no local intent is an out-of-band payment
+                        // (provider panel payment-link, dashboard link/invoice, wallet, card
+                        // terminal). It is recorded in inbound_provider_events and ACKed, but
+                        // there is no order to settle, invoice, or fulfill — the safe no-op above
+                        // is intentional and preserved. Emit a vendor-neutral, non-paging
+                        // reconciliation signal so the money is never silently lost.
+                        // Fires once per unique provider event (`!replayed`): the ingest RPC is
+                        // idempotent on (provider, provider_event_id), so PSP re-delivery is a
+                        // natural throttle.
+                        operationalEvents({
+                            name: "provider_payment_unmatched_out_of_band",
+                            domain: "payment",
+                            surface: "webhook",
+                            details: {
+                                provider,
+                                providerPaymentId: event.providerPaymentId,
+                                eventType: event.eventType,
+                                resultStatus,
+                                amountMinor: event.amountMinor ?? null,
+                                currency: event.currency ?? null,
+                                occurredAt: event.occurredAt,
+                            },
+                        });
+                    }
+                    if (ports.methodRefPort) {
+                        await ports.methodRefPort.upsertFromWebhook(event);
+                    }
+                    if (ports.afterProcessed) {
+                        await ports.afterProcessed({ event, ingested, resultStatus });
+                    }
+                    // Reached only when every setup mutation above resolved (a throw 5xx's →
+                    // provider redelivers into a still-'received' row). Runs on replays too,
+                    // so redelivery self-heals rows stuck from before this closer existed.
+                    if (resultStatus === null && event.eventType.startsWith("setup.") && ports.paymentControlPort.markSetupEventProcessed) {
+                        await ports.paymentControlPort.markSetupEventProcessed({ paymentEventId: ingested.paymentEventId });
+                    }
+                    sendSuccess(res, {
+                        provider,
+                        providerEventId: event.providerEventId,
+                        paymentEventId: ingested.paymentEventId,
+                        replayed: ingested.replayed,
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    // A genuine idempotency conflict (same key, different payload) is a client
+                    // 409, not a transient 5xx — a 503 would make the provider retry a request
+                    // that can never succeed. The method-ref RPC raises this on a fingerprint
+                    // mismatch (SQLSTATE 23505).
+                    if (/payment_method_ref_idempotency_conflict|commerce_idempotency_conflict|\b23505\b/.test(message)) {
+                        sendBffError(res, "CONFLICT", "Webhook idempotency conflict");
+                        return;
+                    }
+                    // A `succeeded` result that arrives AFTER the provisional-subscription
+                    // sweep has already terminalized the intent (cancelled/refunded/…) is
+                    // rejected by `apply_result` with `payment_control_result_terminal_intent`
+                    // (ERRCODE 22023). The money question is already settled from the control
+                    // plane's perspective, so this is a "no work left to do" outcome, not a
+                    // transient upstream failure — ACK 200 so the provider stops
+                    // retrying for days (retry-storm / charge-without-fulfillment risk). We
+                    // match the RPC's exception text specifically, NOT the bare 22023 code,
+                    // because 22023 is also raised for genuine mismatches (amount / currency /
+                    // intent-not-found) that must still surface as 503.
+                    if (event && /payment_control_result_terminal_intent/.test(message)) {
+                        operationalEvents({
+                            name: "provider_payment_result_after_terminal_intent",
+                            domain: "payment",
+                            surface: "webhook",
+                            details: {
+                                provider,
+                                providerEventId: event.providerEventId,
+                                providerPaymentId: event.providerPaymentId,
+                                eventType: event.eventType,
+                                occurredAt: event.occurredAt,
+                            },
+                        });
+                        sendSuccess(res, {
+                            provider,
+                            providerEventId: event.providerEventId,
+                            acknowledged: true,
+                            skipped: "result_terminal_intent",
+                        });
+                        return;
+                    }
+                    // The event cannot be attributed to the intent's exact active attempt:
+                    // either it named another attempt (the slow-webhook shape and possible
+                    // double charge) or ingest could not correlate it at all. Neither answer
+                    // changes on redelivery, so ACK 200 instead of creating an endless retry
+                    // loop. The durable inbound event and this reason route operator recovery.
+                    // Match named reasons only, never the shared 22023 SQLSTATE.
+                    if (event && /payment_control_result_attempt_(?:mismatch|unresolved)/.test(message)) {
+                        const reason = message.includes("payment_control_result_attempt_unresolved")
+                            ? "attempt_unresolved"
+                            : "attempt_mismatch";
+                        operationalEvents({
+                            name: "provider_payment_result_attempt_mismatch",
+                            domain: "payment",
+                            surface: "webhook",
+                            // `providerPaymentId`, not `providerEventId`, is the operator's handle:
+                            // the detail allowlist carries the former and drops the latter, and it
+                            // is the value `ingest_event` correlated the attempt from.
+                            details: {
+                                provider,
+                                providerPaymentId: event.providerPaymentId,
+                                eventType: event.eventType,
+                                resultStatus: mapResultStatus(event, refundEvidencePolicy),
+                                occurredAt: event.occurredAt,
+                                reason,
+                            },
+                        });
+                        sendSuccess(res, {
+                            provider,
+                            providerEventId: event.providerEventId,
+                            acknowledged: true,
+                            skipped: "result_attempt_mismatch",
+                        });
+                        return;
+                    }
+                    sendBffError(res, "UPSTREAM_UNAVAILABLE", "Provider webhook processing failed");
+                }
+            }
+        } };
+}
+function mapResultStatus(event, refundEvidencePolicy) {
+    if (event.eventType === "payment.succeeded")
+        return "succeeded";
+    if (event.eventType === "payment.failed")
+        return "failed";
+    if (event.eventType === "payment.refunded") {
+        if (refundEvidencePolicy === "require-evidence" && (event.refundKind == null || !event.providerPaymentId.trim() || !Number.isSafeInteger(event.amountMinor) || (event.amountMinor ?? 0) <= 0 || !event.currency?.trim()))
+            return null;
+        return event.refundKind === "partial" ? "partially_refunded" : "refunded";
+    }
+    if (event.eventType === "payment.disputed")
+        return "disputed";
+    return null;
+}
+// "Money moved" for reconciliation purposes: a settled charge, a refund, or a
+// chargeback/dispute. `failed` (no money moved) and `null` (setup / non-money
+// events) are excluded — an unmatched failed/setup event needs no reconciliation.
+function isMoneyMoved(resultStatus) {
+    return resultStatus !== null && resultStatus !== "failed";
+}

package/dist/shipping/bindings.d.ts

@@ -1,3 +1,4 @@
+import type { ReadinessReport, SchemaObservation } from "@openlup/core/readiness";
 import type { BffResponder } from "../bff/index.js";
 import type { CustomerAddressBookPort, CustomerAddressMutationPort, CustomerAddressesDeps } from "./addressPorts.js";
 import type { CustomerAddressSchemas } from "./addressSchemas.js";
@@ -16,6 +17,10 @@ type Store = {
 export interface ShippingBindingDependencies {
     dataKind: string;
     createManagedStore?: () => Store | null;
+    /** Core report for the selected shipping contribution, observed by the host. */
+    nativeRateReadiness?: ReadinessReport;
+    /** Same-database Core observation of the applied shipping seed and required objects. */
+    nativeRateSchema?: SchemaObservation;
     nativeStore?: Omit<Store, "addressMutationPort"> | null;
     responder: BffResponder;
     selection?: {

package/dist/shipping/bindings.js

@@ -5,7 +5,17 @@ import { createDeliveryOptionsHandler, createPickupPointSearchHandler, createPic
 export function createShippingBindings(deps) {
     const native = deps.dataKind === "postgres";
     const addressWrites = native ? "shipping_native_address_writes_unsupported" : null;
-    const flatRateSave = native ? "shipping_native_flat_rate_save_unsupported" : null;
+    const nativeRateReady = typeof deps.nativeStore?.shippingRateDataPort?.getShippingFlatMinor === "function"
+        && typeof deps.nativeStore?.shippingRateDataPort?.setShippingFlatMinor === "function"
+        && typeof deps.nativeStore?.shippingRateDataPort?.recordPromotionAudit === "function"
+        && deps.nativeRateReadiness?.state === "ready"
+        && typeof deps.nativeRateReadiness.candidate?.database === "string"
+        && deps.nativeRateReadiness.candidate.database.length > 0
+        && deps.nativeRateSchema?.database === deps.nativeRateReadiness.candidate.database
+        && deps.nativeRateSchema.version === "20261021200000_shipping_flat_rate_seed"
+        && ["public.commerce_settings", "public.commerce_settings.value_minor", "public.commerce_settings.updated_at"].every(name => deps.nativeRateSchema?.objects?.some(entry => entry.present === true && entry.object?.name === name
+            && entry.object.kind === (name === "public.commerce_settings" ? "table" : "column")));
+    const flatRateSave = native && !nativeRateReady ? "shipping_native_flat_rate_save_unsupported" : null;
     const refused = (reason) => ({
         store: {}, handlers: { options: null, search: null, validate: null, addresses: null, rate: null },
         readiness: { ready: false, reason }, unsupported: { addressWrites, flatRateSave },
@@ -14,7 +24,7 @@ export function createShippingBindings(deps) {
         return refused("shipping_store_incompatible");
     if (native && deps.addresses?.requireWrites)
         return refused(addressWrites);
-    if (native && deps.rate)
+    if (native && deps.rate && flatRateSave)
         return refused(flatRateSave);
     const selected = native ? deps.nativeStore : deps.createManagedStore?.();
     if ((deps.addresses || deps.rate) && !selected)

package/dist/shipping/index.d.ts

@@ -18,3 +18,17 @@ export type { AdminShippingRateHandlerDeps, ShippingRateDataPort, ShippingRateHa
 export { createShippingBindings, type ShippingBindingDependencies, type ShippingBindings } from "./bindings.js";
 export type { ShippingTerms, ShippingPolicyEntry, ShippingPolicy, ShippingSettings } from "./contracts/threshold.js";
 export { shippingTermsSchema, shippingPolicySchema, parseShippingTerms, hasShippingTerms, normalizeShippingPolicy, resolveShippingPolicy, resolveThresholdShipping } from "./thresholdPolicy.js";
+/** Sparse canonical projections, never an install chain. */
+export declare const SHIPPING_MIGRATIONS: readonly [{
+    readonly id: "20260807140000_read_parity_catalog";
+    readonly catalogPath: "db/platform/migrations/20260807140000_read_parity_catalog.sql";
+    readonly position: 1;
+    readonly sha256: "fcf3827028c1651ae42a7c7d7472153825a3121c936d58a3d105befc7dece9ea";
+    readonly url: URL;
+}, {
+    readonly id: "20261021200000_shipping_flat_rate_seed";
+    readonly catalogPath: "db/platform/migrations/20261021200000_shipping_flat_rate_seed.sql";
+    readonly position: 72;
+    readonly sha256: "34f8696f515a2cc072395db5a3de2d9b09643d13236ee3851d0d78123f907eae";
+    readonly url: URL;
+}];

package/dist/shipping/index.js

@@ -8,3 +8,8 @@ export { readAddresses, readOrdererProfiles, addressUsedByActiveSubscription, ad
 export { createAdminShippingRateHandler } from "./adminShippingRateHandler.js";
 export { createShippingBindings } from "./bindings.js";
 export { shippingTermsSchema, shippingPolicySchema, parseShippingTerms, hasShippingTerms, normalizeShippingPolicy, resolveShippingPolicy, resolveThresholdShipping } from "./thresholdPolicy.js";
+/** Sparse canonical projections, never an install chain. */
+export const SHIPPING_MIGRATIONS = [
+    { id: "20260807140000_read_parity_catalog", catalogPath: "db/platform/migrations/20260807140000_read_parity_catalog.sql", position: 1, sha256: "fcf3827028c1651ae42a7c7d7472153825a3121c936d58a3d105befc7dece9ea", url: new URL("../../sql/20260807140000_read_parity_catalog.sql", import.meta.url) },
+    { id: "20261021200000_shipping_flat_rate_seed", catalogPath: "db/platform/migrations/20261021200000_shipping_flat_rate_seed.sql", position: 72, sha256: "34f8696f515a2cc072395db5a3de2d9b09643d13236ee3851d0d78123f907eae", url: new URL("../../sql/20261021200000_shipping_flat_rate_seed.sql", import.meta.url) },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlup/platform",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "private": false,
   "description": "Runnable server substrate: Node HTTP runtime, BFF dispatch, scheduler, storage, data gateways and bundle composition; development preview.",
   "license": "Apache-2.0",
@@ -31,7 +31,7 @@
     "api:update": "npm run build && node --experimental-strip-types ./scripts/api-contract.ts --update"
   },
   "peerDependencies": {
-    "@openlup/core": "0.19.0",
+    "@openlup/core": "0.21.0",
     "pg": "^8.22.0",
     "@aws-sdk/client-s3": "^3.1144.0",
     "@types/pg": "^8.20.0"
@@ -175,6 +175,26 @@
       "types": "./dist/shipping/contracts/index.d.ts",
       "import": "./dist/shipping/contracts/index.js",
       "default": "./dist/shipping/contracts/index.js"
+    },
+    "./payments": {
+      "types": "./dist/payments/index.d.ts",
+      "import": "./dist/payments/index.js",
+      "default": "./dist/payments/index.js"
+    },
+    "./payments/contracts": {
+      "types": "./dist/payments/contracts/index.d.ts",
+      "import": "./dist/payments/contracts/index.js",
+      "default": "./dist/payments/contracts/index.js"
+    },
+    "./payments/stripe": {
+      "types": "./dist/payments/stripe/index.d.ts",
+      "import": "./dist/payments/stripe/index.js",
+      "default": "./dist/payments/stripe/index.js"
+    },
+    "./payments/tpay": {
+      "types": "./dist/payments/tpay/index.d.ts",
+      "import": "./dist/payments/tpay/index.js",
+      "default": "./dist/payments/tpay/index.js"
     }
   },
   "repository": {