@openlup/platform 0.27.0 → 0.29.0

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

@@ -0,0 +1,289 @@
+import type { OperatorContext } from "./customer360.js";
+export type OperatorSubscriptionAction = "pause" | "resume" | "slide_next_cycle" | "change_shipping_address";
+export interface OperatorNewShippingAddress {
+    recipientName: string;
+    line1: string;
+    line2?: string;
+    postalCode: string;
+    city: string;
+    country: string;
+    contactPhone?: string;
+}
+export type OperatorShippingAddressPayload = {
+    shippingAddressId: string;
+    reason?: string;
+} | {
+    newAddress: OperatorNewShippingAddress;
+    reason?: string;
+};
+export type OperatorSubscriptionPayload = {
+    pausePreset?: "2_weeks" | "1_month" | "indefinite";
+    reason?: string;
+    newNextCycleAt?: string;
+    slideMinDays?: number;
+    confirmedChargeTiming?: boolean;
+} | OperatorShippingAddressPayload;
+export type OperatorSubscriptionRefusal = "subscription_not_found" | "subject_not_found" | "subject_account_unlinked" | "version_conflict" | "slide_target_invalid" | "slide_not_available" | "slide_out_of_window" | "payment_blocked" | "invalid_transition" | "charge_timing_not_confirmed" | "payment_method_not_chargeable" | "invalid_address";
+export type RecoveryRefusal = "subject_not_found" | "case_not_found" | "lifecycle_not_eligible" | "dunning_authority_unavailable" | "case_not_open" | "recoverable_order_unavailable";
+export type EmailCorrectionRefusal = "subject_not_found" | "subject_account_linked" | "email_expectation_conflict" | "email_already_in_use";
+export type PhoneCorrectionRefusal = "subject_not_found" | "phone_expectation_conflict";
+export type LeadRefusal = "lead_not_found" | "customer_not_found" | "lead_email_expectation_conflict" | "lead_has_identity" | "lead_has_commercial_footprint" | "unclassified_referencing_table";
+export type OperatorContactCommand = {
+    action: "correct_email";
+    subjectId: string;
+    expectedEmail: string;
+    newEmail: string;
+    idempotencyKey: string;
+} | {
+    action: "correct_phone";
+    subjectId: string;
+    expectedPhone: string;
+    newPhone: string;
+    idempotencyKey: string;
+};
+export interface OperatorLeadCommand {
+    action: "absorb_lead";
+    subjectId: string;
+    leadId: string;
+    expectedLeadEmail: string;
+    idempotencyKey: string;
+}
+export type OperatorRecoveryCommand = {
+    action: "issue_recovery";
+    subjectId: string;
+    caseId: string;
+    idempotencyKey: string;
+} | {
+    action: "apply_subscription_action";
+    subscriptionId: string;
+    subscriptionAction: OperatorSubscriptionAction;
+    expectedVersion: number;
+    idempotencyKey: string;
+    payload?: OperatorSubscriptionPayload;
+} | OperatorContactCommand | OperatorLeadCommand;
+/** Carries trusted context and the original command; performs no authorization or writes.
+ * The host preserves the command key, optional reason and expected version.
+ */
+export interface OperatorRecoveryCommandEnvelope<Command = OperatorRecoveryCommand> {
+    actor: OperatorContext;
+    subject: {
+        subjectId: string;
+        subscriptionId?: string;
+        orderId?: string;
+        caseId?: string;
+    };
+    command: Command;
+    reason: string | null;
+    idempotencyKey: string;
+    expectedVersion: number | null;
+    evidence: readonly {
+        owner: string;
+        resourceId: string;
+        revision: string | null;
+    }[];
+}
+export type OperatorSubscriptionResult = {
+    outcome: "applied" | "noop" | "replayed";
+    subscriptionStatus: string;
+    nextCycleAt: string | null;
+    templateVersion: number;
+    eventId: string | null;
+    appliedBy: "operator_reschedule_band" | "customer_self_service_delegate" | null;
+} | {
+    outcome: "refused" | "conflict";
+    refusalCode: OperatorSubscriptionRefusal;
+};
+/** Actual M10 receipt evidence; support never manufactures an audit identifier. */
+export interface OperatorOwnerReceipt {
+    id: string;
+    actorId: string;
+    idempotencyKey: string;
+    commandFingerprint: string;
+    result: Record<string, unknown>;
+}
+/** Additive native superset. The managed transcription above remains unchanged. */
+export type NativeOperatorSubscriptionResult = (OperatorSubscriptionResult & {
+    ownerReceipt?: OperatorOwnerReceipt;
+}) | {
+    outcome: "refused";
+    refusalCode: "operator_subscription_authority_unavailable";
+    ownerReceipt?: OperatorOwnerReceipt;
+};
+export type OperatorAuthorityUnavailable = {
+    outcome: "refused";
+    refusalCode: "operator_subscription_authority_unavailable";
+};
+export type OperatorEmailCorrectionResult = {
+    outcome: "applied" | "noop" | "replayed";
+    authUserLinked: boolean;
+} | {
+    outcome: "refused" | "conflict";
+    refusalCode: EmailCorrectionRefusal;
+};
+export type OperatorPhoneCorrectionResult = {
+    outcome: "applied" | "noop" | "replayed";
+} | {
+    outcome: "refused" | "conflict";
+    refusalCode: PhoneCorrectionRefusal;
+};
+export type CustomerRecoveryAuthorityResult = {
+    outcome: "issued";
+    deliveryStatus: string;
+    auditEventId: string;
+} | {
+    outcome: "replayed";
+    deliveryStatus: string;
+    auditEventId: string;
+} | {
+    outcome: "refused";
+    refusalCode: RecoveryRefusal;
+} | {
+    outcome: "conflict";
+    conflictCode: "idempotency_conflict";
+};
+export interface LeadAbsorptionCarried {
+    personalization: number;
+    consents: number;
+    sourceLinks: number;
+    deliveries: number;
+}
+export type OperatorLeadAbsorptionResult = {
+    outcome: "applied" | "noop" | "replayed";
+    leadId: string;
+    customerId: string;
+    carried: LeadAbsorptionCarried;
+} | {
+    outcome: "refused" | "conflict";
+    leadId: string;
+    refusalCode: LeadRefusal;
+    blockingTables: string[];
+};
+export interface OperatorEmailCorrectionClaim {
+    idempotencyKey: string;
+    claimToken: string;
+    sequence: string;
+}
+export interface OperatorIdentityMovePort {
+    findClientHoldingEmail(email: string): Promise<{
+        clientId: string;
+    } | null>;
+    readIdentityEmail(authUserId: string): Promise<string>;
+    moveIdentityEmail(authUserId: string, email: string, claim: OperatorEmailCorrectionClaim): Promise<void>;
+}
+export type OperatorEmailCorrectionAdmission = OperatorEmailCorrectionResult | {
+    outcome: "admitted";
+    authUserId: string | null;
+    originalEmail: string;
+    newEmail: string;
+};
+export type OperatorEmailCorrectionPhase = "complete" | "release" | "fail";
+export type OperatorEmailCorrectionSettlement = OperatorEmailCorrectionResult | {
+    outcome: "pending";
+} | {
+    outcome: "failed";
+};
+export type OperatorEmailCorrectionExecution = OperatorEmailCorrectionSettlement | (OperatorEmailCorrectionClaim & {
+    outcome: "claimed";
+    authUserId: string | null;
+    originalEmail: string;
+    newEmail: string;
+});
+export type OperatorAccountLinkRefusal = "subject_not_found" | "subject_not_customer" | "subject_email_missing" | "email_expectation_conflict" | "subject_account_linked" | "identity_not_linkable" | "identity_linked_elsewhere";
+export type OperatorAccountLinkResult = {
+    outcome: "applied" | "noop" | "replayed";
+} | {
+    outcome: "refused" | "conflict";
+    refusalCode: OperatorAccountLinkRefusal;
+};
+export interface OperatorAccountLinkRequest {
+    action: "link_account";
+    subjectId: string;
+    expectedEmail: string;
+    idempotencyKey: string;
+}
+export interface OperatorAccountLinkIdentityPort {
+    findSubject(clientId: string): Promise<{
+        identityKind: string | null;
+        email: string | null;
+        authUserId: string | null;
+    } | null>;
+    resolveIdentityForEmail(email: string): Promise<string>;
+}
+export interface OperatorSubscriptionInput {
+    subscriptionId: string;
+    subscriptionAction: OperatorSubscriptionAction;
+    expectedVersion: number;
+    payload: OperatorSubscriptionPayload;
+    idempotencyKey: string;
+    operatorId: string;
+}
+export interface OperatorEmailInput {
+    subjectId: string;
+    expectedEmail: string;
+    newEmail: string;
+    idempotencyKey: string;
+    operatorId: string;
+}
+export interface OperatorPhoneInput {
+    subjectId: string;
+    expectedPhone: string;
+    newPhone: string;
+    idempotencyKey: string;
+    operatorId: string;
+}
+export interface OperatorLinkInput {
+    subjectId: string;
+    expectedEmail: string;
+    authUserId: string | null;
+    idempotencyKey: string;
+    operatorId: string;
+}
+export interface OperatorRecoveryInput {
+    subjectId: string;
+    caseId: string;
+    idempotencyKey: string;
+    operatorId: string;
+}
+export interface OperatorAbsorptionInput {
+    customerId: string;
+    leadId: string;
+    expectedLeadEmail: string;
+    idempotencyKey: string;
+    operatorId: string;
+}
+export interface ManagedOperatorAuthorityPort {
+    applySubscriptionAction(input: OperatorSubscriptionInput): Promise<OperatorSubscriptionResult>;
+    correctSubjectEmail(input: OperatorEmailInput): Promise<OperatorEmailCorrectionAdmission>;
+    claimSubjectEmail(input: {
+        idempotencyKey: string;
+    }): Promise<OperatorEmailCorrectionExecution>;
+    settleSubjectEmail(input: {
+        idempotencyKey: string;
+        claimToken: string;
+        phase: OperatorEmailCorrectionPhase;
+    }): Promise<OperatorEmailCorrectionSettlement>;
+    correctSubjectPhone(input: OperatorPhoneInput): Promise<OperatorPhoneCorrectionResult>;
+    linkSubjectAccount(input: OperatorLinkInput): Promise<OperatorAccountLinkResult>;
+    issueRecovery(input: OperatorRecoveryInput): Promise<CustomerRecoveryAuthorityResult>;
+    absorbLead(input: OperatorAbsorptionInput): Promise<OperatorLeadAbsorptionResult>;
+}
+export interface NativeOperatorAuthorityPort {
+    applySubscriptionAction(input: OperatorSubscriptionInput): Promise<NativeOperatorSubscriptionResult>;
+    correctSubjectEmail(input: OperatorEmailInput): Promise<OperatorAuthorityUnavailable>;
+    correctSubjectPhone(input: OperatorPhoneInput): Promise<OperatorAuthorityUnavailable>;
+    linkSubjectAccount(input: OperatorLinkInput): Promise<OperatorAuthorityUnavailable>;
+    issueRecovery(input: OperatorRecoveryInput): Promise<CustomerRecoveryAuthorityResult>;
+    absorbLead(input: OperatorAbsorptionInput): Promise<OperatorLeadAbsorptionResult>;
+}
+export type LinkThenSubscriptionResult = {
+    outcome: "link_refused";
+    link: OperatorAccountLinkResult | OperatorAuthorityUnavailable;
+} | {
+    outcome: "completed";
+    link: OperatorAccountLinkResult;
+    subscription: NativeOperatorSubscriptionResult;
+} | {
+    outcome: "partial";
+    link: OperatorAccountLinkResult;
+    subscription: NativeOperatorSubscriptionResult | null;
+};

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

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

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

@@ -0,0 +1,24 @@
+import type { AccountSupportCapabilities } from "./contracts/index.js";
+import type { AccountSupportCallable, AccountSupportOperations } from "./bindings.js";
+export type AccountSupportBindingRefusal = {
+    readonly kind: "refused";
+    readonly code: "disabled" | "schema_unknown" | "schema_unsatisfied";
+};
+export type AccountSupportReadiness = {
+    readonly kind: "ready";
+} | AccountSupportBindingRefusal;
+export type GuardedAccountSupportOperation<F> = F extends AccountSupportCallable ? (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>> | AccountSupportBindingRefusal> : null;
+export type GuardedAccountSupportOperations<O extends AccountSupportOperations> = {
+    readonly [K in keyof O]: GuardedAccountSupportOperation<O[K]>;
+};
+/** One guard per callable identity, shared by service, port and route aliases. */
+export declare function createAccountSupportServices<O extends AccountSupportOperations>(input: {
+    enabled?: boolean;
+    capabilities: AccountSupportCapabilities;
+    operations: O;
+    readiness(): Promise<AccountSupportReadiness>;
+}): Readonly<{
+    capabilities: AccountSupportCapabilities;
+    readiness: () => Promise<AccountSupportReadiness>;
+    operations: Readonly<GuardedAccountSupportOperations<O>>;
+}>;

package/dist/account-support/contribution.js

@@ -0,0 +1,22 @@
+/** One guard per callable identity, shared by service, port and route aliases. */
+export function createAccountSupportServices(input) {
+    const enabled = input.enabled === true, observe = input.readiness;
+    async function readiness() {
+        return enabled ? observe() : { kind: "refused", code: "disabled" };
+    }
+    const guards = new Map();
+    const operations = Object.fromEntries(Object.entries(input.operations).map(([key, operation]) => {
+        if (operation === null)
+            return [key, null];
+        let guarded = guards.get(operation);
+        if (!guarded) {
+            guarded = async (...args) => {
+                const state = await readiness();
+                return state.kind === "ready" ? operation(...args) : state;
+            };
+            guards.set(operation, guarded);
+        }
+        return [key, guarded];
+    }));
+    return Object.freeze({ capabilities: input.capabilities, readiness, operations: Object.freeze(operations) });
+}

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

@@ -0,0 +1,106 @@
+import type { Customer360Snapshot, Customer360Subject, Customer360ContactHealth, Customer360ReadPort, Customer360Lookup, Customer360SummaryReadPort, DiagnosticHistoryReadPort } from "./contracts/customer360.js";
+export declare const SUPPORT_CUSTOMER_360_CONTRACT_VERSION: "support.customer_360.v2";
+type Row = Record<string, unknown>;
+export type CustomerJourneyAuditEvent = {
+    eventId: string;
+    occurredAt: string;
+    action: string;
+    outcome: string;
+    entity: {
+        kind: "subject" | "order" | "subscription" | "dunning_case";
+        id: string;
+    };
+};
+export interface ContactHealthDelivery {
+    readonly status: string;
+    readonly occurredAt: string | null;
+    readonly permanentBounce: boolean | null;
+}
+export interface Customer360ProjectionInput<Extension = unknown> {
+    subject: {
+        subjectId: string;
+        displayName: string | null;
+        email: string | null;
+        phone?: string | null;
+        lifecycleStage: Customer360Subject["lifecycleStage"];
+        createdAt: string | null;
+        lastActivityAt: string | null;
+    };
+    legacy: {
+        lookup: {
+            warnings: string[];
+        };
+        customer: {
+            authUserLinked: boolean;
+        };
+        orders: {
+            orderId: string;
+            orderNumber: string | null;
+            status: string | null;
+            omsProjection: Row;
+        }[];
+        subscriptions: {
+            subscriptionId: string;
+            status: string | null;
+            nextCycleAt: string | null;
+            templateVersion?: number | null;
+            paymentMethodStatus?: string | null;
+            renewalOrders: Row[];
+        }[];
+        payment: {
+            status: string | null;
+            intents: Row[];
+        };
+        timeline: Row[];
+    } | null;
+    cases: Row[];
+    notices: Row[];
+    tokens: Row[];
+    recoveryAudit: Row[];
+    orderTruth: Row[];
+    now: number;
+    contactHealth?: Customer360ContactHealth | null;
+    signedIn?: boolean;
+    addresses?: Customer360Snapshot["addresses"] | null;
+    subscriptionPointers?: Map<string, {
+        shippingAddressId: string | null;
+        paymentMethodKind: string | null;
+    }> | null;
+    /** false means failed/unavailable; null means no enrichment selected. */
+    profile?: {
+        extension: Extension;
+        partial: boolean;
+    } | false | null;
+}
+export interface Customer360ProjectionPolicy {
+    lifecycle(subject: Customer360ProjectionInput["subject"]): Customer360Subject["lifecycle"];
+    /** Stable audit identity hashing remains in the server host. */
+    timelineAudit(event: Row, subjectId: string): CustomerJourneyAuditEvent[];
+}
+export declare function projectCustomer360Snapshot<Extension>(input: Customer360ProjectionInput<Extension>, policy: Customer360ProjectionPolicy): Customer360Snapshot<Extension>;
+export declare function boundedCustomerJourneyAudit(events: CustomerJourneyAuditEvent[]): {
+    events: CustomerJourneyAuditEvent[];
+    windowed: boolean;
+};
+export declare function deriveContactHealth(deliveries: readonly ContactHealthDelivery[]): Customer360ContactHealth;
+/** Authorize before every source read; retain host defaults, ambiguity, null and failure semantics. */
+export declare function createCustomer360ReadFacade<Search, Snapshot, SummaryRequest, SummaryResult, DiagnosticRequest, DiagnosticResult>(ports: {
+    authorize(): Promise<boolean>;
+    journey: Customer360ReadPort<Search, Snapshot>;
+    summary: Customer360SummaryReadPort<SummaryRequest, SummaryResult>;
+    diagnostics: DiagnosticHistoryReadPort<DiagnosticRequest, DiagnosticResult>;
+}): {
+    searchCustomerJourney: (request: Customer360Lookup) => Promise<Search | {
+        kind: "denied";
+    }>;
+    getCustomerJourney: (request: Customer360Lookup) => Promise<Snapshot | {
+        kind: "denied";
+    } | null>;
+    getPortableSummary: (request: SummaryRequest) => Promise<SummaryResult | {
+        kind: "denied";
+    }>;
+    history: (request: DiagnosticRequest) => Promise<DiagnosticResult | {
+        kind: "denied";
+    }>;
+};
+export {};

package/dist/account-support/customer360.js

@@ -0,0 +1,163 @@
+export const SUPPORT_CUSTOMER_360_CONTRACT_VERSION = "support.customer_360.v2";
+export function projectCustomer360Snapshot(input, policy) {
+    const { subject, legacy, cases, notices, tokens, recoveryAudit, orderTruth, now } = input;
+    const orders = legacy?.orders.map(order => ({
+        orderId: order.orderId,
+        orderNumber: order.orderNumber,
+        status: order.status ?? "unknown",
+        subscriptionId: string(order.omsProjection.subscriptionId),
+        totalMinor: integer(order.omsProjection.totalMinor),
+        currency: string(order.omsProjection.currency),
+        createdAt: date(order.omsProjection.createdAt)
+    })) ?? [];
+    const pending = (row) => orderTruth.some(order => order.id === row.order_id && order.client_id === row.client_id && order.status === "pending_payment");
+    const eligible = (row) => subject.lifecycleStage === "customer" && row.status === "open" && pending(row);
+    const audit = boundedCustomerJourneyAudit([
+        ...(legacy?.timeline ?? []).flatMap(event => policy.timelineAudit(event, subject.subjectId)),
+        ...recoveryAudit.flatMap(recoveryEvent)
+    ]);
+    const profile = input.profile;
+    const warnings = [...new Set([
+            ...(legacy?.lookup.warnings ?? []),
+            ...(audit.windowed ? ["evidence_window_limited:customer_360_audit_trail"] : []),
+            ...(recoveryAudit.length === 80 ? ["evidence_window_limited:customer_recovery_audit"] : []),
+            ...(profile === false ? ["evidence_unavailable:customer_profile"] : profile?.partial ? ["evidence_partial:customer_profile"] : [])
+        ])];
+    return {
+        contractVersion: SUPPORT_CUSTOMER_360_CONTRACT_VERSION,
+        lookup: { query: subject.subjectId, matchedBy: "subject_id", confidence: "exact", warnings },
+        ...(input.contactHealth ? { contactHealth: input.contactHealth } : {}),
+        ...(input.addresses ? { addresses: input.addresses } : {}),
+        ...(profile ? { extension: profile.extension } : {}),
+        subject: {
+            subjectId: subject.subjectId,
+            displayName: subject.displayName,
+            email: subject.email,
+            phone: subject.phone ?? null,
+            lifecycleStage: subject.lifecycleStage,
+            lifecycle: policy.lifecycle(subject),
+            firstSeenAt: subject.createdAt,
+            lastActivityAt: latest([...(legacy?.timeline ?? []), ...cases, ...recoveryAudit]) ?? subject.lastActivityAt,
+            ...(legacy ? { authUserLinked: legacy.customer.authUserLinked } : {}),
+            ...(input.signedIn === undefined ? {} : { hasSignedIn: input.signedIn })
+        },
+        orders,
+        subscriptions: legacy?.subscriptions.map(value => ({
+            subscriptionId: value.subscriptionId,
+            status: value.status ?? "unknown",
+            nextCycleAt: value.nextCycleAt,
+            latestOrderId: string(value.renewalOrders[0]?.orderId),
+            ...(typeof value.templateVersion === "number" ? { templateVersion: value.templateVersion } : {}),
+            ...(input.subscriptionPointers
+                ? {
+                    shippingAddressId: input.subscriptionPointers.get(value.subscriptionId)?.shippingAddressId ?? null,
+                    paymentMethodKind: input.subscriptionPointers.get(value.subscriptionId)?.paymentMethodKind ?? null
+                }
+                : {}),
+            paymentMethodStatus: string(value.paymentMethodStatus)
+        })) ?? [],
+        payment: orders.map(order => {
+            const intent = legacy?.payment.intents.find(value => string(value.orderId) === order.orderId);
+            return {
+                orderId: order.orderId,
+                status: string(intent?.status) ?? legacy?.payment.status ?? "unknown",
+                recoverable: cases.some(row => row.order_id === order.orderId && eligible(row)),
+                amountMinor: order.totalMinor,
+                currency: order.currency,
+                lastAttemptAt: date(intent?.updatedAt)
+            };
+        }),
+        dunningCases: cases.map(row => ({
+            caseId: string(row.id),
+            subscriptionId: string(row.subscription_id),
+            orderId: string(row.order_id),
+            status: string(row.status) ?? "unknown",
+            retryAttempt: integer(row.retry_attempt) ?? 0,
+            nextRetryAt: date(row.next_retry_at),
+            notificationStatus: string(latestNotice(notices, string(row.id))?.status),
+            recoveryAvailable: eligible(row)
+        })),
+        recovery: cases.map(row => {
+            const id = string(row.id), related = tokens.filter(value => value.case_id === id);
+            return {
+                caseId: id,
+                status: pending(row) && related.some(value => {
+                    const expiry = date(value.expires_at);
+                    return Boolean(expiry && Date.parse(expiry) > now && !value.used_at && !value.revoked_at);
+                }) ? "available" : "unavailable",
+                actionAvailable: eligible(row),
+                lastIssuedAt: related.map(value => date(value.created_at)).filter(value => value !== null).sort().at(-1) ?? null,
+                lastDeliveryStatus: string(latestNotice(notices, id, "payment_recovery")?.status)
+            };
+        }),
+        auditTrail: audit.events
+    };
+}
+export function boundedCustomerJourneyAudit(events) {
+    const instant = (value) => Number.isFinite(Date.parse(value)) ? Date.parse(value) : 0;
+    const newest = [...events].sort((a, b) => instant(b.occurredAt) - instant(a.occurredAt) || a.eventId.localeCompare(b.eventId));
+    return {
+        events: newest.slice(0, 80).sort((a, b) => instant(a.occurredAt) - instant(b.occurredAt) || a.eventId.localeCompare(b.eventId)),
+        windowed: newest.length > 80
+    };
+}
+export function deriveContactHealth(deliveries) {
+    const terminal = ["delivered", "bounced", "complained", "failed"];
+    const newest = deliveries.filter((value) => terminal.includes(value.status) && typeof value.occurredAt === "string")
+        .reduce((best, value) => best === null || value.occurredAt > best.occurredAt ? value : best, null);
+    if (!newest)
+        return { lastTerminalStatus: null, lastTerminalAt: null, reachable: true };
+    return {
+        lastTerminalStatus: newest.status,
+        lastTerminalAt: newest.occurredAt,
+        reachable: newest.status === "delivered" || (newest.status === "bounced" && newest.permanentBounce === false)
+    };
+}
+/** Authorize before every source read; retain host defaults, ambiguity, null and failure semantics. */
+export function createCustomer360ReadFacade(ports) {
+    async function read(query) {
+        if (!await ports.authorize())
+            return { kind: "denied" };
+        return query();
+    }
+    return {
+        searchCustomerJourney: (request) => read(() => ports.journey.searchCustomerJourney(request)),
+        getCustomerJourney: (request) => read(() => ports.journey.getCustomerJourney(request)),
+        getPortableSummary: (request) => read(() => ports.summary.getPortableSummary(request)),
+        history: (request) => read(() => ports.diagnostics.history(request))
+    };
+}
+function recoveryEvent(row) {
+    const eventId = string(row.id), occurredAt = date(row.occurred_at), id = string(row.case_id), outcome = string(row.outcome);
+    if (!eventId || !occurredAt || !id || !outcome)
+        return [];
+    const refusal = string(row.refusal_code);
+    return [{
+            eventId,
+            occurredAt,
+            action: "recovery.issue",
+            outcome: refusal ? `${outcome}:${refusal}` : outcome,
+            entity: { kind: "dunning_case", id }
+        }];
+}
+function latestNotice(rows, id, kind) {
+    return rows.filter(row => row.case_id === id && row.recipient_kind === "customer" && (!kind || row.notification_kind === kind))
+        .sort((a, b) => `${string(b.created_at) ?? ""}:${string(b.id) ?? ""}`.localeCompare(`${string(a.created_at) ?? ""}:${string(a.id) ?? ""}`))[0];
+}
+function string(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function integer(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function date(value) {
+    const text = string(value);
+    return text && !Number.isNaN(Date.parse(text)) ? text : null;
+}
+function latest(rows) {
+    return rows.map(row => date(row.updated_at ?? row.updatedAt ?? row.created_at ?? row.createdAt ?? row.occurred_at ?? row.occurredAt))
+        .filter(value => value !== null)
+        .sort((a, b) => Date.parse(a) - Date.parse(b))
+        .at(-1)
+        ?? null;
+}

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

@@ -0,0 +1,11 @@
+export type CustomerAccountReadStage = "account_aggregate";
+type DiagnosticRecord = Record<string, unknown>;
+export declare class CustomerAccountReadModelError extends Error {
+    readonly stage: CustomerAccountReadStage;
+    readonly cause: unknown;
+    constructor(stage: CustomerAccountReadStage, cause: unknown);
+}
+export declare function withCustomerAccountReadStage<T>(stage: CustomerAccountReadStage, operation: () => Promise<T>): Promise<T>;
+export declare function customerAccountReadFailureDetails(error: unknown): DiagnosticRecord;
+export declare function logCustomerAccountReadFailure(error: unknown): void;
+export {};