@openlup/platform 0.26.0 → 0.28.0

package/dist/account-support/accountReadModels.js

@@ -0,0 +1,272 @@
+export const CUSTOMER_ACCOUNT_V2_CONTRACT_VERSION = "customer.account.v3";
+/** Two observation stages, including the original nested subscription fan-out. Auth/ownership precedes this call. */
+export async function readAccountSnapshot(sources, policy, client) {
+    const clientId = text(client.id);
+    const [extension, allRows, addresses, ordererProfiles, paymentPreferences, deliveryPreferences, orders, events] = await Promise.all([
+        sources.readExtension(clientId),
+        sources.readSubscriptionRows(clientId, 50),
+        sources.readAddresses(clientId),
+        sources.readOrdererProfiles(clientId),
+        sources.readPaymentPreferences(clientId),
+        sources.readDeliveryPreferences(clientId),
+        sources.readOrders(clientId, 20),
+        sources.readEvents(clientId),
+    ]);
+    const rows = allRows.filter(isCustomerVisibleSubscription);
+    const ids = rows.map(row => text(row.id));
+    const [subscriptions, states] = await Promise.all([
+        assemble(sources, policy, rows, clientId, nullableText(client.email)),
+        sources.readActionStates(ids),
+    ]);
+    return {
+        contractVersion: CUSTOMER_ACCOUNT_V2_CONTRACT_VERSION,
+        profile: profile(client),
+        extension,
+        subscriptions,
+        addresses,
+        ordererProfiles,
+        billingProfiles: ordererProfiles,
+        paymentPreferences,
+        deliveryPreferences,
+        recentOrders: orders.orders,
+        events,
+        actionRequired: buildActionRequired(subscriptions, orders.orders, states, policy.canUsePaymentMethodForRenewal)
+    };
+}
+async function assemble(sources, policy, rows, clientId, clientEmail) {
+    const ids = rows.map(row => text(row.id));
+    const cycles = new Map(rows.map(row => [text(row.id), nullableText(row.next_cycle_at)]));
+    const [lines, blockers, pauses, evidence, alignments, next] = await Promise.all([
+        sources.readSubscriptionLines(ids),
+        sources.readSubscriptionBlockers(ids, cycles),
+        sources.readPauseWindows(ids),
+        sources.readPaymentEvidence(ids),
+        sources.readDeliveryAlignments(cycles),
+        sources.readNextCharges(rows),
+    ]);
+    return rows.map(row => {
+        const subscriptionId = text(row.id), status = text(row.status);
+        const cutoff = editCutoff(nullableText(row.next_cycle_at), typeof row.edit_window_hours === "number" ? row.edit_window_hours : null);
+        const paymentMethodStatus = policy.paymentMethodStatus({ clientId, clientEmail, row, evidence: evidence.get(subscriptionId) });
+        const edit = computeEditState({
+            subscriptionId,
+            status,
+            nextCycleAt: nullableText(row.next_cycle_at),
+            editCutoffAt: cutoff,
+            paymentMethodKind: nullableText(row.payment_method_kind),
+            paymentMethodRefPresent: Boolean(nullableText(row.payment_method_ref)),
+            paymentMethodStatus
+        }, blockers, policy.canUsePaymentMethodForRenewal);
+        const items = lines.get(subscriptionId) ?? [], pause = pauses.get(subscriptionId);
+        return {
+            subscriptionId,
+            shippingAddressId: nullableText(row.shipping_address_id),
+            status,
+            pausePreset: pause?.pausePreset ?? null,
+            pauseStartedAt: pause?.pauseStartedAt ?? null,
+            pauseEndsAt: pause?.pauseEndsAt ?? null,
+            cadenceDays: Number(row.cadence_days),
+            nextCycleAt: nullableText(row.next_cycle_at),
+            ...(alignments.has(subscriptionId) ? { deliveryAlignment: alignments.get(subscriptionId) } : {}),
+            editCutoffAt: cutoff,
+            canEditUpcomingPackage: edit.canEdit,
+            editBlockedReason: edit.reason,
+            paymentMethodKind: nullableText(row.payment_method_kind),
+            paymentMethodStatus,
+            templateVersion: Number(row.template_version),
+            sizeConstraint: record(row.size_constraint),
+            packageSummary: policy.packageSummary(items, row.size_constraint),
+            ...policy.withNextCharge(recurringPrice(items), next.get(subscriptionId)),
+            lines: items
+        };
+    });
+}
+export function isCustomerVisibleSubscription(row) {
+    return ["active", "paused", "pending_activation"].includes(text(row.status))
+        || (row.status === "cancelled" && row.cancellation_source === "customer_self_service");
+}
+export function recurringPrice(lines) {
+    if (!lines.length)
+        return null;
+    let amount = 0, currency = null;
+    for (const line of lines) {
+        const money = line.lineSubtotal;
+        if (typeof money?.amountMinor !== "number" || typeof money.currency !== "string"
+            || (currency !== null && currency !== money.currency))
+            return null;
+        currency = money.currency;
+        amount += money.amountMinor;
+    }
+    if (currency === null)
+        return null;
+    return {
+        subtotalGross: { amountMinor: amount, currency },
+        totalGross: { amountMinor: amount, currency },
+        currency,
+        source: "frozen_quote_line"
+    };
+}
+export function editCutoff(nextCycleAt, editWindowHours) {
+    if (!nextCycleAt)
+        return null;
+    const date = new Date(nextCycleAt);
+    date.setHours(date.getHours() - (editWindowHours ?? 72));
+    return date.toISOString();
+}
+export function computeEditState(input, blockers, canUse) {
+    if (input.status !== "active")
+        return { canEdit: false, reason: "not_active" };
+    const reason = blockers.get(input.subscriptionId);
+    if (reason)
+        return { canEdit: false, reason };
+    const usable = input.paymentMethodStatus
+        ? canUse(input.paymentMethodStatus)
+        : Boolean(input.paymentMethodKind && input.paymentMethodRefPresent);
+    if (!usable)
+        return { canEdit: false, reason: "missing_payment_method" };
+    if (input.editCutoffAt && new Date(input.editCutoffAt).getTime() <= Date.now())
+        return { canEdit: false, reason: "edit_window_closed" };
+    return { canEdit: true, reason: null };
+}
+export function buildActionRequired(subscriptions, orders, states = new Map(), canUse) {
+    const actions = [];
+    for (const s of subscriptions) {
+        const state = states.get(s.subscriptionId);
+        const base = {
+            entityType: "subscription",
+            entityId: s.subscriptionId,
+            subscriptionId: s.subscriptionId,
+            orderId: state?.orderId ?? null,
+            failureCause: state?.failureCause ?? "unknown",
+            dueAt: state?.dueAt ?? s.nextCycleAt,
+            nextRetryAt: state?.nextRetryAt ?? null,
+            recoveryEligible: state?.recoveryEligible ?? false
+        };
+        if (state?.blockedReason === "subscription_activation_missing_mandate") {
+            actions.push({
+                ...base,
+                actionId: `subscription:${s.subscriptionId}:activation_missing_mandate`,
+                kind: "payment_method_missing",
+                severity: "critical",
+                messageCode: "subscription_activation_missing_mandate",
+                blockedReason: "subscription_activation_missing_mandate",
+                failureCause: "unknown",
+                title: "First order paid, subscription needs a payment method",
+                body: "The first order is paid. Add a card to enable future renewals without charging that order again.",
+                cta: "repair_payment",
+                recoveryEligible: false,
+                dueAt: state.dueAt,
+                nextRetryAt: null
+            });
+            continue;
+        }
+        if (s.status !== "active" && s.status !== "paused")
+            continue;
+        if (state?.blockedReason === "payment_expired") {
+            actions.push({
+                ...base,
+                actionId: `subscription:${s.subscriptionId}:payment_expired`,
+                kind: "payment_recovery",
+                severity: "critical",
+                messageCode: "payment_expired",
+                blockedReason: "payment_expired",
+                title: "Subscription paused after payment could not be collected",
+                body: "Every retry has been used, so nothing else will be attempted. Update the payment method to resume; the unpaid cycle is skipped and a new one starts from the resume date.",
+                cta: "repair_payment",
+                dueAt: state.dueAt,
+                nextRetryAt: null
+            });
+            continue;
+        }
+        if (state) {
+            actions.push({
+                ...base,
+                actionId: `subscription:${s.subscriptionId}:payment_blocked`,
+                kind: state.recoveryEligible ? "payment_recovery" : "subscription_blocked",
+                severity: "critical",
+                messageCode: state.blockedReason ?? "payment_blocked",
+                blockedReason: state.blockedReason,
+                title: "Payment needs attention",
+                body: state.recoveryEligible
+                    ? "Your subscription is blocked until the payment method is recovered."
+                    : "Your subscription has a payment issue that needs support review.",
+                cta: state.recoveryEligible ? "repair_payment" : "contact_support"
+            });
+            continue;
+        }
+        if (!(s.paymentMethodStatus ? canUse(s.paymentMethodStatus) : Boolean(s.paymentMethodKind)))
+            actions.push({
+                ...base,
+                actionId: `subscription:${s.subscriptionId}:payment_method_missing`,
+                kind: "payment_method_missing",
+                severity: "warning",
+                messageCode: "missing_payment_method",
+                blockedReason: "missing_payment_method",
+                title: "Payment method missing",
+                body: "Add or recover a payment method before the next subscription cycle.",
+                cta: "contact_support"
+            });
+    }
+    for (const order of orders) {
+        const status = order.paymentStatus?.toLowerCase() ?? "", failed = ["failed", "payment_failed", "requires_payment_method"].includes(status), required = ["requires_action", "requires_confirmation"].includes(status);
+        if (failed || required)
+            actions.push({
+                actionId: `order:${order.orderId}:${required ? "requires_action" : "payment_failed"}`,
+                kind: "order_attention",
+                severity: "critical",
+                entityType: "order",
+                entityId: order.orderId,
+                subscriptionId: null,
+                orderId: order.orderId,
+                messageCode: required ? "payment_requires_action" : "payment_failed",
+                blockedReason: required ? "payment_requires_action" : "payment_failed",
+                failureCause: "unknown",
+                title: required ? "Payment requires action" : "Payment failed",
+                body: "Open the order details to review the payment status and next step.",
+                cta: "view_order",
+                recoveryEligible: false,
+                dueAt: order.updatedAt,
+                nextRetryAt: null
+            });
+        const invoice = order.invoice;
+        if (invoice && !invoice.downloadAvailable && ["issued", "accepted"].includes(invoice.status))
+            actions.push({
+                actionId: `invoice:${invoice.invoiceId}:pdf_unavailable`,
+                kind: "invoice_attention",
+                severity: "info",
+                entityType: "invoice",
+                entityId: invoice.invoiceId,
+                subscriptionId: null,
+                orderId: order.orderId,
+                messageCode: "invoice_pdf_unavailable",
+                blockedReason: "invoice_pdf_unavailable",
+                failureCause: "unknown",
+                title: "Invoice PDF unavailable",
+                body: "The invoice is visible, but the PDF cannot be downloaded from the account yet.",
+                cta: "contact_support",
+                recoveryEligible: false,
+                dueAt: invoice.issuedAt ?? invoice.createdAt,
+                nextRetryAt: null
+            });
+    }
+    return actions.slice(0, 8);
+}
+function profile(row) {
+    return {
+        clientId: text(row.id),
+        email: text(row.email),
+        firstName: nullableText(row.first_name),
+        lastName: nullableText(row.last_name),
+        phone: nullableText(row.phone),
+        lifecycleStage: text(row.lifecycle_stage)
+    };
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function nullableText(value) {
+    return typeof value === "string" && value ? value : null;
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}

package/dist/account-support/bindings.d.ts

@@ -0,0 +1,23 @@
+import type { AccountSupportCapabilities } from "./contracts/index.js";
+/** Already bound owner methods; the host retains authentication and dispatch. */
+export type AccountSupportCallable = (...args: never[]) => unknown;
+export type AccountSupportOperations = Readonly<Record<string, AccountSupportCallable | null>>;
+export type AccountSupportHostBindingRequired = {
+    readonly kind: "unsupported";
+    readonly code: "host_binding_required";
+};
+type CommerceArguments<F> = F extends AccountSupportCallable ? Parameters<F> : unknown[];
+/** Capture one graph and one executor per logical operation, without calling either. */
+export declare function createAccountSupportBindings<O extends AccountSupportOperations, C extends AccountSupportOperations = AccountSupportOperations>(input: {
+    graph: "managed" | "native";
+    capabilities: AccountSupportCapabilities;
+    operations: O;
+    commerce?: C | null;
+}): Readonly<{
+    graph: "managed" | "native";
+    capabilities: Readonly<AccountSupportCapabilities>;
+    operations: Readonly<O>;
+    /** No draft commerce import or fallback executor. An absent record/member is explicit. */
+    commerce<K extends keyof C & string>(key: K, ...args: CommerceArguments<C[K]>): Promise<Awaited<ReturnType<Extract<C[K], AccountSupportCallable>>> | AccountSupportHostBindingRequired>;
+}>;
+export {};

package/dist/account-support/bindings.js

@@ -0,0 +1,16 @@
+const HOST_BINDING_REQUIRED = Object.freeze({ kind: "unsupported", code: "host_binding_required" });
+/** Capture one graph and one executor per logical operation, without calling either. */
+export function createAccountSupportBindings(input) {
+    if (input.graph !== input.capabilities.graph)
+        throw new Error("customer_graph_mismatch");
+    const capabilities = Object.freeze({ ...input.capabilities, subscriptions: Object.freeze({ ...input.capabilities.subscriptions }) });
+    const operations = Object.freeze({ ...input.operations });
+    const commerce = Object.freeze({ ...input.commerce });
+    return Object.freeze({ graph: input.graph, capabilities, operations,
+        /** No draft commerce import or fallback executor. An absent record/member is explicit. */
+        async commerce(key, ...args) {
+            const operation = Object.hasOwn(commerce, key) ? commerce[key] : null;
+            return operation ? operation(...args) : HOST_BINDING_REQUIRED;
+        },
+    });
+}

package/dist/account-support/contracts/account.d.ts

@@ -0,0 +1,281 @@
+/** Host-verified selection; never an authorization claim from a request body. */
+export interface CustomerContext {
+    principalId: string;
+    clientId: string;
+    graph: "managed" | "native";
+}
+export type AccountReadRefusal = "FORBIDDEN" | "NOT_FOUND" | "UPSTREAM_UNAVAILABLE" | "INVALID_RESPONSE";
+/** Owner DTOs stay host supplied, including private profile and market fields.
+ * Null and thrown failures retain their existing host mappings. No cursor is promised.
+ */
+export interface AccountReadPort<Account, OrderList, OrderDetail> {
+    getAccount(userId: string): Promise<Account | null>;
+    listOrders(userId: string, input: {
+        limit: number;
+    }): Promise<OrderList | null>;
+    getOrderDetail(userId: string, orderId: string): Promise<OrderDetail | null>;
+}
+import type { AccountSupportMoney, SubscriptionPaymentMethodStatus } from "./commands.js";
+import type { CustomerDocumentDeliveryStatus } from "./invoice.js";
+export interface AccountProfile {
+    clientId: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    phone: string | null;
+    lifecycleStage: "lead" | "tester" | "customer" | "inactive";
+}
+export interface AccountAddress {
+    addressId: string;
+    kind: "shipping" | "billing" | "both";
+    label: string | null;
+    recipientName: string | null;
+    contactPhone: string | null;
+    companyName: string | null;
+    taxId: string | null;
+    line1: string;
+    line2: string | null;
+    city: string;
+    postalCode: string;
+    country: string;
+    isDefault: boolean;
+    deliveryNotes: string | null;
+    courierInstructions: string | null;
+    lastUsedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AccountBillingProfile {
+    profileId: string;
+    label: string | null;
+    fullName: string;
+    email: string;
+    phone: string | null;
+    companyName: string | null;
+    taxId: string | null;
+    companyVerificationLevel?: "registry_verified" | "provider_verified" | "manual_unverified" | "invalid" | null;
+    companyIdentitySource?: string | null;
+    companyIdentityEvidenceHash?: string | null;
+    isDefault: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Method/provider vocabulary is supplied by the selected host, never a platform provider list. */
+export interface AccountPaymentPreference<Method extends string = string> {
+    scope: "one_time" | "subscription" | "any";
+    methodKind: Method;
+    lastSelectedAt: string;
+}
+export interface AccountPickupPoint {
+    id: string;
+    name: string;
+    address: {
+        line1: string;
+        postalCode: string;
+        city: string;
+        country: string;
+    } | null;
+}
+export interface AccountDeliverySelection {
+    deliveryKind: "courier" | "parcel-locker";
+    providerKind: string | null;
+    carrierKind: string | null;
+    carrierCode: string | null;
+    serviceCode: string | null;
+    pickupPoint: AccountPickupPoint | null;
+}
+export interface AccountDeliveryPreference<Provider extends string = string> extends AccountDeliverySelection {
+    scope: "one_time" | "subscription" | "any";
+    providerKind: Provider;
+    carrierKind: string;
+    carrierCode: string;
+    serviceCode: string;
+    lastSelectedAt: string;
+}
+export interface AccountEvent {
+    eventId: string;
+    eventType: string;
+    entityType: string;
+    entityId: string | null;
+    occurredAt: string;
+}
+export interface AccountSubscriptionLine {
+    lineId: string;
+    variantId: string;
+    qty: number;
+    sortOrder: number;
+    isAddon: boolean;
+    title: string | null;
+    sku: string | null;
+    productSlug?: string | null;
+    displayLabel?: string | null;
+    accentColor?: string | null;
+    unitPrice?: AccountSupportMoney | null;
+    lineSubtotal?: AccountSupportMoney | null;
+}
+export interface AccountSubscription {
+    subscriptionId: string;
+    shippingAddressId: string | null;
+    status: "pending_activation" | "active" | "paused" | "cancelled" | "activation_failed" | "completed";
+    pausePreset: "2_weeks" | "1_month" | "indefinite" | null;
+    pauseStartedAt: string | null;
+    pauseEndsAt: string | null;
+    cadenceDays: number;
+    nextCycleAt: string | null;
+    deliveryAlignment?: {
+        state: "protected" | "aligned";
+    };
+    editCutoffAt: string | null;
+    canEditUpcomingPackage: boolean;
+    editBlockedReason: "not_active" | "edit_window_closed" | "cycle_locked" | "payment_blocked" | "missing_payment_method" | null;
+    paymentMethodKind: string | null;
+    paymentMethodStatus?: SubscriptionPaymentMethodStatus;
+    templateVersion: number;
+    sizeConstraint: Record<string, unknown> | null;
+    packageSummary: string | null;
+    recurringPrice: {
+        subtotalGross: AccountSupportMoney;
+        totalGross: AccountSupportMoney;
+        currency: string;
+        source: "frozen_quote_line" | "missing";
+    } | null;
+    nextCharge?: {
+        totalGross: AccountSupportMoney;
+        starterStage: "delivery2" | "graduation" | null;
+    } | null;
+    lines: AccountSubscriptionLine[];
+}
+export interface AccountTrackingReference {
+    providerKind: string;
+    trackingNumber: string;
+    trackingUrl: string | null;
+    carrierKind: string | null;
+    service: string | null;
+    updatedAt: string | null;
+}
+export interface AccountTrackingEvent {
+    eventType: string;
+    label: string;
+    occurredAt: string | null;
+    source: "webhook" | "reconciliation" | "manual" | "simulator" | "fulfillment";
+}
+export interface AccountInvoiceSummary {
+    invoiceId: string;
+    orderId: string;
+    invoiceRef: string;
+    status: string;
+    providerInvoiceNumber: string | null;
+    ksefNumber: string | null;
+    ksefStatus: string;
+    documentDeliveryStatus: CustomerDocumentDeliveryStatus;
+    totalGross: AccountSupportMoney;
+    issuedAt: string | null;
+    downloadAvailable: boolean;
+    downloadUrl: string | null;
+    createdAt: string;
+}
+export interface AccountInvoiceDocument extends Omit<AccountInvoiceSummary, "totalGross"> {
+    documentKey: string;
+    role: "original" | "correction" | "replacement";
+    artifact: "invoice" | "correction";
+    isCurrent: boolean;
+    totalGross: AccountSupportMoney | null;
+}
+export interface AccountOrderSummary {
+    orderId: string;
+    orderRef: string;
+    orderNumber: string | null;
+    subscriptionId: string | null;
+    status: string;
+    paymentStatus: string | null;
+    fulfillmentStatus: string | null;
+    customerFulfillmentStep?: "paid" | "accepted" | "packing" | "transit" | "delivered" | "exception" | "cancelled";
+    total: AccountSupportMoney;
+    trackingNumber: string | null;
+    trackingNumbers: string[];
+    trackingUrl: string | null;
+    carrierKind: string | null;
+    service: string | null;
+    trackingReferences: AccountTrackingReference[];
+    trackingTimeline: AccountTrackingEvent[];
+    deliverySelection: AccountDeliverySelection | null;
+    invoice: AccountInvoiceSummary | null;
+    invoiceDocuments: AccountInvoiceDocument[];
+    invoiceRequestStatus: "not_requested" | "preparing" | "available";
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AccountOrderLine {
+    lineId: string;
+    skuId: string | null;
+    title: string;
+    quantity: number;
+    unitPrice: AccountSupportMoney;
+    total: AccountSupportMoney;
+    variantName: string | null;
+    productSlug?: string | null;
+    displayLabel?: string | null;
+    accentColor?: string | null;
+    listTotal?: AccountSupportMoney | null;
+    discount?: AccountSupportMoney | null;
+}
+export interface AccountFulfillmentSummary {
+    fulfillmentOrderId: string | null;
+    status: string | null;
+    providerKind: string | null;
+    trackingNumber: string | null;
+    trackingNumbers: string[];
+    trackingReferences: AccountTrackingReference[];
+    lastEventType: string | null;
+    updatedAt: string | null;
+    trackingTimeline: AccountTrackingEvent[];
+}
+export interface AccountOrderDetail extends AccountOrderSummary {
+    subtotal: AccountSupportMoney;
+    discount: AccountSupportMoney;
+    shipping: AccountSupportMoney;
+    tax: AccountSupportMoney;
+    lines: AccountOrderLine[];
+    fulfillment: AccountFulfillmentSummary | null;
+}
+export interface AccountOrderList {
+    contractVersion: "customer.orders.v2";
+    orders: AccountOrderSummary[];
+}
+export interface AccountOrderDetailResponse {
+    contractVersion: "customer.orders.v2";
+    order: AccountOrderDetail;
+}
+export interface AccountActionRequired {
+    actionId: string;
+    kind: "payment_recovery" | "payment_method_missing" | "subscription_blocked" | "order_attention" | "invoice_attention";
+    severity: "info" | "warning" | "critical";
+    entityType: "subscription" | "order" | "invoice" | "account";
+    entityId: string | null;
+    subscriptionId: string | null;
+    orderId: string | null;
+    messageCode: AccountActionMessage;
+    blockedReason: AccountActionMessage | null;
+    title: string;
+    body: string | null;
+    cta: "repair_payment" | "view_subscription" | "view_order" | "contact_support" | null;
+    failureCause: "needs_confirmation" | "method_cannot_recur" | "method_dead" | "method_data_invalid" | "method_missing" | "unknown";
+    recoveryEligible: boolean;
+    dueAt: string | null;
+    nextRetryAt: string | null;
+}
+export type AccountActionMessage = "payment_blocked" | "payment_expired" | "missing_payment_method" | "payment_failed" | "payment_requires_action" | "subscription_edit_blocked" | "invoice_pdf_unavailable" | "subscription_activation_missing_mandate";
+export interface AccountSnapshot<Extension = unknown> {
+    contractVersion: "customer.account.v3";
+    profile: AccountProfile;
+    extension: Extension;
+    subscriptions: AccountSubscription[];
+    addresses: AccountAddress[];
+    ordererProfiles: AccountBillingProfile[];
+    billingProfiles: AccountBillingProfile[];
+    paymentPreferences: AccountPaymentPreference[];
+    deliveryPreferences: AccountDeliveryPreference[];
+    recentOrders: AccountOrderSummary[];
+    events: AccountEvent[];
+    actionRequired: AccountActionRequired[];
+}

package/dist/account-support/contracts/account.js

@@ -0,0 +1 @@
+export {};

package/dist/account-support/contracts/capabilities.d.ts

@@ -0,0 +1,44 @@
+import type { SubscriptionCapabilities } from "./commands.js";
+export type AccountSupportCapability<Code extends string> = {
+    supported: true;
+} | {
+    supported: false;
+    refusalCode: Code;
+};
+export type AccountSupportLaneUnavailable<Code extends string> = Extract<AccountSupportCapability<Code>, {
+    supported: false;
+}>;
+/** Explicit driver selections; importing the module installs no capability. */
+export interface AccountSupportCapabilities {
+    graph: "managed" | "native";
+    accountRead: AccountSupportCapability<"host_binding_required">;
+    customer360Read: AccountSupportCapability<"host_binding_required">;
+    invoiceAccess: AccountSupportCapability<"host_binding_required">;
+    paymentMethodSetup: AccountSupportCapability<"unsupported">;
+    commerceRecovery: AccountSupportCapability<"host_binding_required">;
+    configuredPurchase: AccountSupportCapability<"host_binding_required">;
+    operatorSubscription: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    operatorContact: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    subscriptions: SubscriptionCapabilities;
+    communicationGifts: AccountSupportCapability<"unsupported_preference">;
+}
+/** Per-action/subcase truth, independent of the host's unrelated read selections. */
+export interface OperatorAuthorityCapabilities {
+    graph: "managed" | "native";
+    email: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    phone: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    link: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    address: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    shortBand: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    unpaidResume: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    preparedAttemptPause: AccountSupportCapability<"operator_subscription_authority_unavailable">;
+    pause: {
+        supported: true;
+    };
+    resume: {
+        supported: true;
+    };
+    slide: {
+        supported: true;
+    };
+}

package/dist/account-support/contracts/capabilities.js

@@ -0,0 +1 @@
+export {};