@voyant-travel/finance 0.119.5

package/dist/service-invoices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-invoices.d.ts","sourceRoot":"","sources":["../src/service-invoices.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMjC,CAAA"}

package/dist/service-invoices.js

@@ -0,0 +1,12 @@
+import { financeInvoiceCoreService } from "./service-invoice-core.js";
+import { financeInvoiceCreditNoteService } from "./service-invoice-credit-notes.js";
+import { financeInvoiceFromBookingService } from "./service-invoice-from-booking.js";
+import { financeInvoiceLineItemService } from "./service-invoice-line-items.js";
+import { financeInvoicePaymentService } from "./service-invoice-payments.js";
+export const financeInvoiceService = {
+    ...financeInvoiceCoreService,
+    ...financeInvoiceFromBookingService,
+    ...financeInvoiceLineItemService,
+    ...financeInvoicePaymentService,
+    ...financeInvoiceCreditNoteService,
+};

package/dist/service-issue.d.ts

@@ -0,0 +1,207 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { bookingPaymentSchedules, invoices } from "./schema.js";
+import { type CreateInvoiceFromBookingInput, type FinanceServiceRuntime, type InvoiceFromBookingData } from "./service.js";
+/**
+ * Issue / proforma orchestration helpers that wrap the bare invoice
+ * creators with EventBus emissions so subscribers (SmartBill plugin,
+ * checkout-finalize workflow) can react.
+ *
+ * `createInvoice*` services in `service.ts` stay pure DB writers —
+ * the workflow / route layer chooses when to mark them as "issued"
+ * (a status change that's also a system signal).
+ */
+export interface InvoiceIssueRuntime extends FinanceServiceRuntime {
+}
+interface ExistingConvertedInvoicePointer {
+    id: string;
+    invoiceNumber: string;
+}
+export interface InvoiceIssuedEvent {
+    invoiceId: string;
+    invoiceNumber: string;
+    invoiceType: "invoice" | "proforma" | "credit_note";
+    bookingId: string | null;
+    totalCents: number;
+    currency: string;
+    /** Operator accounting/reporting currency when different from `currency`. */
+    baseCurrency?: string;
+    /** Rate set used to resolve `currency` -> `baseCurrency`, when available. */
+    fxRateSetId?: string;
+    /** Spot rate for `currency` → `baseCurrency`. */
+    fxRate?: number;
+    /** Provider or reference source for `fxRate`, for example `bnr`. */
+    fxRateSource?: string;
+    /** Provider timestamp for the quoted spot rate. */
+    fxRateQuotedAt?: string;
+    /** Provider timestamp after which the quoted spot rate is stale. */
+    fxRateValidUntil?: string;
+    /** Operator FX commission added on top of the spot rate. */
+    fxCommissionBps?: number;
+    /** `fxRate` after commission. Invoice providers should prefer this rate. */
+    effectiveRate?: number;
+    /** Optional invoice mention appended by providers when commission is non-zero. */
+    fxCommissionInvoiceMention?: string;
+    /** Linkage when this invoice replaced a proforma. */
+    convertedFromInvoiceId?: string | null;
+    clientName?: string;
+    clientEmail?: string | null;
+    clientPhone?: string | null;
+    clientAddress?: string | null;
+    clientCity?: string | null;
+    clientCounty?: string | null;
+    clientCountry?: string | null;
+    clientVatCode?: string | null;
+    clientRegCom?: string | null;
+    lineItems?: InvoiceIssuedLineItem[];
+    bookingNumber?: string | null;
+    issueDate?: string;
+    dueDate?: string;
+    externalAllocationRequired?: boolean;
+    externalProvider?: string | null;
+    externalConfigKey?: string | null;
+    externalSeriesId?: string | null;
+    externalPlaceholderNumber?: string | null;
+    /**
+     * Per-issuance opt-out flag. When `true`, e-invoicing plugins
+     * (SmartBill etc.) ignore this event instead of pushing the document
+     * upstream. Origin: `invoiceFromBookingSchema.skipExternalSync`.
+     */
+    skipExternalSync?: boolean;
+}
+export interface InvoiceIssuedLineItem {
+    description: string;
+    quantity: number;
+    unitPrice: number;
+    currency: string;
+    bookingPaymentScheduleId?: string;
+    scheduleType?: (typeof bookingPaymentSchedules.$inferSelect)["scheduleType"];
+    schedulePercent?: number;
+    taxPercentage?: number;
+    taxName?: string | null;
+    taxRegimeCode?: TaxRegimeCode | null;
+    isService?: boolean;
+}
+export type TaxRegimeCode = "standard" | "reduced" | "exempt" | "reverse_charge" | "margin_scheme_art311" | "zero_rated" | "out_of_scope" | "other";
+export interface InvoiceProformaConvertedEvent extends InvoiceIssuedEvent {
+    id: string;
+    proformaId: string;
+    proformaInvoiceNumber: string;
+}
+/**
+ * Create + emit an invoice from a booking. Returns the persisted row
+ * after flipping the status from `draft` to `issued`. Drafts shouldn't
+ * trigger SmartBill sync.
+ */
+export declare function issueInvoiceFromBooking(db: PostgresJsDatabase, input: CreateInvoiceFromBookingInput, bookingData: InvoiceFromBookingData, runtime?: InvoiceIssueRuntime): Promise<{
+    subtotalCents: number;
+    currency: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    taxRegimeId: string | null;
+    taxCents: number;
+    totalCents: number;
+    status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+    bookingId: string;
+    notes: string | null;
+    templateId: string | null;
+    dueDate: string;
+    invoiceNumber: string;
+    invoiceType: "invoice" | "proforma" | "credit_note";
+    convertedFromInvoiceId: string | null;
+    seriesId: string | null;
+    sequence: number | null;
+    language: string | null;
+    personId: string | null;
+    organizationId: string | null;
+    baseCurrency: string | null;
+    fxRateSetId: string | null;
+    baseSubtotalCents: number | null;
+    baseTaxCents: number | null;
+    baseTotalCents: number | null;
+    paidCents: number;
+    basePaidCents: number | null;
+    balanceDueCents: number;
+    baseBalanceDueCents: number | null;
+    commissionPercent: number | null;
+    commissionAmountCents: number | null;
+    issueDate: string;
+    voidedAt: Date | null;
+    voidReason: string | null;
+} | null>;
+/**
+ * Create + emit a proforma from a booking. Same shape as
+ * `issueInvoiceFromBooking` but marks the row as `invoiceType:
+ * 'proforma'` and emits the proforma-specific event so the
+ * SmartBill plugin can route to its proforma endpoint.
+ */
+export declare function issueProformaFromBooking(db: PostgresJsDatabase, input: CreateInvoiceFromBookingInput, bookingData: InvoiceFromBookingData, runtime?: InvoiceIssueRuntime): Promise<{
+    subtotalCents: number;
+    currency: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    taxRegimeId: string | null;
+    taxCents: number;
+    totalCents: number;
+    status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+    bookingId: string;
+    notes: string | null;
+    templateId: string | null;
+    dueDate: string;
+    invoiceNumber: string;
+    invoiceType: "invoice" | "proforma" | "credit_note";
+    convertedFromInvoiceId: string | null;
+    seriesId: string | null;
+    sequence: number | null;
+    language: string | null;
+    personId: string | null;
+    organizationId: string | null;
+    baseCurrency: string | null;
+    fxRateSetId: string | null;
+    baseSubtotalCents: number | null;
+    baseTaxCents: number | null;
+    baseTotalCents: number | null;
+    paidCents: number;
+    basePaidCents: number | null;
+    balanceDueCents: number;
+    baseBalanceDueCents: number | null;
+    commissionPercent: number | null;
+    commissionAmountCents: number | null;
+    issueDate: string;
+    voidedAt: Date | null;
+    voidReason: string | null;
+} | null>;
+export declare function buildInvoiceIssuedEvent(db: PostgresJsDatabase, invoice: typeof invoices.$inferSelect, runtime?: InvoiceIssueRuntime): Promise<InvoiceIssuedEvent>;
+/**
+ * Convert an issued proforma into a final invoice. Copies the proforma's
+ * line items verbatim (totals + taxes already match the booking the
+ * customer accepted) and voids the proforma so it stops counting against
+ * outstanding balances. The new invoice carries `convertedFromInvoiceId`
+ * so the audit chain is preserved; downstream subscribers see the linkage
+ * on both the generic issued event and the conversion-specific event.
+ *
+ * Number derivation: `PRO-` prefix → `INV-`; otherwise the original
+ * number is suffixed with `-INV`. Callers can override via the optional
+ * `invoiceNumber` argument when they want a series-derived number.
+ */
+export declare function convertProformaToInvoice(db: PostgresJsDatabase, proformaId: string, options?: {
+    invoiceNumber?: string;
+    issueDate?: string;
+    dueDate?: string;
+}, runtime?: InvoiceIssueRuntime): Promise<{
+    status: "ok";
+    invoice: typeof invoices.$inferSelect;
+} | {
+    status: "not_found";
+} | {
+    status: "not_proforma";
+} | {
+    status: "already_converted";
+    invoice: ExistingConvertedInvoicePointer | null;
+} | {
+    status: "duplicate_fiscal_invoice";
+    invoice: ExistingConvertedInvoicePointer;
+}>;
+export {};
+//# sourceMappingURL=service-issue.d.ts.map

package/dist/service-issue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-issue.d.ts","sourceRoot":"","sources":["../src/service-issue.ts"],"names":[],"mappings":"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"}

package/dist/service-issue.js

@@ -0,0 +1,431 @@
+// agent-quality: file-size exception -- owner: finance; existing service module stays co-located until a dedicated split preserves behavior and tests.
+import { appendActionLedgerMutation } from "@voyant-travel/action-ledger";
+import { bookingItems, bookings } from "@voyant-travel/bookings/schema";
+import { and, asc, eq, inArray, ne, sql } from "drizzle-orm";
+import { resolveBookingSellTaxRate } from "./booking-tax.js";
+import { resolveInvoiceFxContext } from "./invoice-fx.js";
+import { isInvoiceNumberUniqueConstraintError } from "./invoice-number-errors.js";
+import { bookingItemTaxLines, bookingPaymentSchedules, invoiceLineItems, invoiceNumberSeries, invoices, payments, } from "./schema.js";
+import { buildInvoiceIssuedActionLedgerInput, financeService, InvoiceNumberConflictError, } from "./service.js";
+const TAX_REGIME_CODES = new Set([
+    "standard",
+    "reduced",
+    "exempt",
+    "reverse_charge",
+    "margin_scheme_art311",
+    "zero_rated",
+    "out_of_scope",
+    "other",
+]);
+const ISSUED_EVENT = "invoice.issued";
+const PROFORMA_ISSUED_EVENT = "invoice.proforma.issued";
+const PROFORMA_CONVERTED_EVENT = "invoice.proforma.converted";
+/**
+ * Create + emit an invoice from a booking. Returns the persisted row
+ * after flipping the status from `draft` to `issued`. Drafts shouldn't
+ * trigger SmartBill sync.
+ */
+export async function issueInvoiceFromBooking(db, input, bookingData, runtime = {}) {
+    const draft = await financeService.createInvoiceFromBooking(db, input, bookingData, runtime);
+    if (!draft)
+        return null;
+    const status = draft.status === "pending_external_allocation" ? draft.status : "issued";
+    const updateIssuedInvoice = (writer) => writer
+        .update(invoices)
+        .set({ status, updatedAt: new Date() })
+        .where(eq(invoices.id, draft.id))
+        .returning();
+    const actionLedgerContext = runtime.actionLedgerContext;
+    const issued = actionLedgerContext
+        ? await db.transaction(async (tx) => {
+            const [row] = await updateIssuedInvoice(tx);
+            if (row) {
+                await appendActionLedgerMutation(tx, await buildInvoiceIssuedActionLedgerInput(actionLedgerContext, { invoice: row }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+            }
+            return row;
+        })
+        : (await updateIssuedInvoice(db))[0];
+    const row = issued ?? draft;
+    await emitIssued(db, runtime, ISSUED_EVENT, row, { skipExternalSync: input.skipExternalSync });
+    return row;
+}
+/**
+ * Create + emit a proforma from a booking. Same shape as
+ * `issueInvoiceFromBooking` but marks the row as `invoiceType:
+ * 'proforma'` and emits the proforma-specific event so the
+ * SmartBill plugin can route to its proforma endpoint.
+ */
+export async function issueProformaFromBooking(db, input, bookingData, runtime = {}) {
+    const draft = await financeService.createInvoiceFromBooking(db, input, bookingData, runtime);
+    if (!draft)
+        return null;
+    const status = draft.status === "pending_external_allocation" ? draft.status : "issued";
+    const updateIssuedInvoice = (writer) => writer
+        .update(invoices)
+        .set({ invoiceType: "proforma", status, updatedAt: new Date() })
+        .where(eq(invoices.id, draft.id))
+        .returning();
+    const actionLedgerContext = runtime.actionLedgerContext;
+    const issued = actionLedgerContext
+        ? await db.transaction(async (tx) => {
+            const [row] = await updateIssuedInvoice(tx);
+            if (row) {
+                await appendActionLedgerMutation(tx, await buildInvoiceIssuedActionLedgerInput(actionLedgerContext, { invoice: row }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+            }
+            return row;
+        })
+        : (await updateIssuedInvoice(db))[0];
+    const row = issued ?? draft;
+    await emitIssued(db, runtime, PROFORMA_ISSUED_EVENT, row, {
+        skipExternalSync: input.skipExternalSync,
+    });
+    return row;
+}
+async function emitIssued(db, runtime, eventName, invoice, options = {}) {
+    if (!runtime.eventBus)
+        return;
+    const payload = await buildInvoiceIssuedEvent(db, invoice, runtime);
+    if (options.skipExternalSync)
+        payload.skipExternalSync = true;
+    await runtime.eventBus.emit(eventName, payload);
+}
+async function emitProformaConverted(db, runtime, invoice, proforma) {
+    if (!runtime.eventBus)
+        return;
+    const issuedEvent = await buildInvoiceIssuedEvent(db, invoice, runtime);
+    const payload = {
+        ...issuedEvent,
+        id: issuedEvent.invoiceId,
+        proformaId: proforma.id,
+        proformaInvoiceNumber: proforma.invoiceNumber,
+    };
+    await runtime.eventBus.emit(ISSUED_EVENT, issuedEvent);
+    await runtime.eventBus.emit(PROFORMA_CONVERTED_EVENT, payload);
+}
+export async function buildInvoiceIssuedEvent(db, invoice, runtime = {}) {
+    const [booking] = invoice.bookingId
+        ? await db.select().from(bookings).where(eq(bookings.id, invoice.bookingId)).limit(1)
+        : [];
+    const [series] = invoice.seriesId && invoice.status === "pending_external_allocation"
+        ? await db
+            .select()
+            .from(invoiceNumberSeries)
+            .where(eq(invoiceNumberSeries.id, invoice.seriesId))
+            .limit(1)
+        : [];
+    const lines = await db
+        .select()
+        .from(invoiceLineItems)
+        .where(eq(invoiceLineItems.invoiceId, invoice.id))
+        .orderBy(asc(invoiceLineItems.sortOrder));
+    const taxMetadataByBookingItemId = await loadLineTaxMetadata(db, lines);
+    const scheduleMetadataById = await loadLineScheduleMetadata(db, lines);
+    const payload = {
+        invoiceId: invoice.id,
+        invoiceNumber: invoice.invoiceNumber,
+        invoiceType: invoice.invoiceType,
+        bookingId: invoice.bookingId,
+        totalCents: invoice.totalCents,
+        currency: invoice.currency,
+        convertedFromInvoiceId: invoice.convertedFromInvoiceId,
+        clientName: buildClientName(booking),
+        clientEmail: booking?.contactEmail ?? null,
+        clientPhone: booking?.contactPhone ?? null,
+        clientAddress: [booking?.contactAddressLine1, booking?.contactAddressLine2].filter(Boolean).join("\n") ||
+            null,
+        clientCity: booking?.contactCity ?? null,
+        clientCounty: booking?.contactRegion ?? null,
+        clientCountry: booking?.contactCountry ?? null,
+        clientVatCode: null,
+        clientRegCom: null,
+        lineItems: lines.map((line) => {
+            const taxMetadata = line.bookingItemId == null ? undefined : taxMetadataByBookingItemId.get(line.bookingItemId);
+            const taxPercentage = line.taxRate ?? taxMetadata?.taxPercentage;
+            const schedule = line.bookingPaymentScheduleId == null
+                ? undefined
+                : scheduleMetadataById.get(line.bookingPaymentScheduleId);
+            const schedulePercent = schedule && booking?.sellAmountCents && booking.sellAmountCents > 0
+                ? Math.round((schedule.amountCents / booking.sellAmountCents) * 100)
+                : undefined;
+            return {
+                description: line.description,
+                quantity: line.quantity,
+                unitPrice: centsToMajor(line.unitPriceCents),
+                currency: invoice.currency,
+                ...(line.bookingPaymentScheduleId == null
+                    ? {}
+                    : { bookingPaymentScheduleId: line.bookingPaymentScheduleId }),
+                ...(schedule?.scheduleType == null ? {} : { scheduleType: schedule.scheduleType }),
+                ...(schedulePercent == null ? {} : { schedulePercent }),
+                ...(taxPercentage == null ? {} : { taxPercentage }),
+                ...(taxMetadata?.taxName == null ? {} : { taxName: taxMetadata.taxName }),
+                ...(taxMetadata?.taxRegimeCode == null ? {} : { taxRegimeCode: taxMetadata.taxRegimeCode }),
+                isService: true,
+            };
+        }),
+        bookingNumber: booking?.bookingNumber ?? null,
+        issueDate: toDateString(invoice.issueDate),
+        dueDate: toDateString(invoice.dueDate),
+    };
+    if (series?.externalProvider) {
+        payload.externalAllocationRequired = true;
+        payload.externalProvider = series.externalProvider;
+        payload.externalConfigKey = series.externalConfigKey;
+        payload.externalSeriesId = series.id;
+        payload.externalPlaceholderNumber = invoice.invoiceNumber;
+    }
+    const fx = await resolveInvoiceFxContext(db, invoice, runtime);
+    if (fx)
+        Object.assign(payload, fx);
+    return payload;
+}
+async function loadLineTaxMetadata(db, lines) {
+    const bookingItemIds = [
+        ...new Set(lines.map((line) => line.bookingItemId).filter((id) => Boolean(id))),
+    ];
+    if (bookingItemIds.length === 0)
+        return new Map();
+    const taxLines = await db
+        .select({
+        bookingItemId: bookingItemTaxLines.bookingItemId,
+        name: bookingItemTaxLines.name,
+        code: bookingItemTaxLines.code,
+        scope: bookingItemTaxLines.scope,
+        rateBasisPoints: bookingItemTaxLines.rateBasisPoints,
+    })
+        .from(bookingItemTaxLines)
+        .where(inArray(bookingItemTaxLines.bookingItemId, bookingItemIds))
+        .orderBy(asc(bookingItemTaxLines.bookingItemId), asc(bookingItemTaxLines.sortOrder), asc(bookingItemTaxLines.createdAt));
+    const taxLinesByBookingItemId = new Map();
+    for (const taxLine of taxLines) {
+        const existing = taxLinesByBookingItemId.get(taxLine.bookingItemId) ?? [];
+        existing.push(taxLine);
+        taxLinesByBookingItemId.set(taxLine.bookingItemId, existing);
+    }
+    const metadataByBookingItemId = new Map();
+    for (const bookingItemId of bookingItemIds) {
+        const taxLine = selectEventTaxLine(taxLinesByBookingItemId.get(bookingItemId) ?? []);
+        if (!taxLine)
+            continue;
+        metadataByBookingItemId.set(bookingItemId, {
+            ...(taxLine.rateBasisPoints == null
+                ? {}
+                : { taxPercentage: Math.round(taxLine.rateBasisPoints / 100) }),
+            taxName: taxLine.name,
+            taxRegimeCode: parseTaxRegimeCode(taxLine.code),
+        });
+    }
+    await backfillMissingLineTaxMetadata(db, bookingItemIds, metadataByBookingItemId);
+    return metadataByBookingItemId;
+}
+async function loadLineScheduleMetadata(db, lines) {
+    const scheduleIds = [
+        ...new Set(lines.map((line) => line.bookingPaymentScheduleId).filter((id) => Boolean(id))),
+    ];
+    if (scheduleIds.length === 0)
+        return new Map();
+    const scheduleRows = await db
+        .select()
+        .from(bookingPaymentSchedules)
+        .where(inArray(bookingPaymentSchedules.id, scheduleIds));
+    return new Map(scheduleRows.map((schedule) => [schedule.id, schedule]));
+}
+function selectEventTaxLine(taxLines) {
+    return (taxLines.find((taxLine) => taxLine.scope !== "withheld" && taxLine.rateBasisPoints != null) ??
+        taxLines.find((taxLine) => taxLine.scope !== "withheld") ??
+        null);
+}
+async function backfillMissingLineTaxMetadata(db, bookingItemIds, metadataByBookingItemId) {
+    const missingBookingItemIds = bookingItemIds.filter((id) => !metadataByBookingItemId.has(id));
+    if (missingBookingItemIds.length === 0)
+        return;
+    const productRows = await db
+        .select({
+        id: bookingItems.id,
+        productId: bookingItems.productId,
+    })
+        .from(bookingItems)
+        .where(inArray(bookingItems.id, missingBookingItemIds));
+    for (const row of productRows) {
+        if (!row.productId)
+            continue;
+        const taxRate = await resolveBookingSellTaxRate(db, { productId: row.productId });
+        if (!taxRate)
+            continue;
+        metadataByBookingItemId.set(row.id, {
+            taxPercentage: Math.round(taxRate.rate * 100),
+            taxName: taxRate.label,
+            taxRegimeCode: parseTaxRegimeCode(taxRate.code),
+        });
+    }
+}
+function parseTaxRegimeCode(code) {
+    const value = code?.split("/").at(-1);
+    return value && TAX_REGIME_CODES.has(value) ? value : null;
+}
+/**
+ * Convert an issued proforma into a final invoice. Copies the proforma's
+ * line items verbatim (totals + taxes already match the booking the
+ * customer accepted) and voids the proforma so it stops counting against
+ * outstanding balances. The new invoice carries `convertedFromInvoiceId`
+ * so the audit chain is preserved; downstream subscribers see the linkage
+ * on both the generic issued event and the conversion-specific event.
+ *
+ * Number derivation: `PRO-` prefix → `INV-`; otherwise the original
+ * number is suffixed with `-INV`. Callers can override via the optional
+ * `invoiceNumber` argument when they want a series-derived number.
+ */
+export async function convertProformaToInvoice(db, proformaId, options = {}, runtime = {}) {
+    const [proforma] = await db.select().from(invoices).where(eq(invoices.id, proformaId)).limit(1);
+    if (!proforma)
+        return { status: "not_found" };
+    if (proforma.invoiceType !== "proforma")
+        return { status: "not_proforma" };
+    const newInvoiceNumber = options.invoiceNumber ?? deriveInvoiceNumberFromProforma(proforma.invoiceNumber);
+    const todayIso = new Date().toISOString().slice(0, 10);
+    const issueDate = options.issueDate ?? todayIso;
+    const dueDate = options.dueDate ?? toDateString(proforma.dueDate);
+    const now = new Date();
+    const result = await db
+        .transaction(async (tx) => {
+        const guardKey = `finance:invoice:convert:${proforma.bookingId}`;
+        // agent-quality: raw-sql reviewed -- owner: finance; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        await tx.execute(sql `SELECT pg_advisory_xact_lock(hashtextextended(${guardKey}, 0))`);
+        const [lockedProforma] = await tx
+            .select()
+            .from(invoices)
+            .where(eq(invoices.id, proformaId))
+            .limit(1);
+        if (!lockedProforma)
+            return { status: "not_found" };
+        if (lockedProforma.invoiceType !== "proforma")
+            return { status: "not_proforma" };
+        const [existing] = await tx
+            .select({ id: invoices.id, invoiceNumber: invoices.invoiceNumber })
+            .from(invoices)
+            .where(eq(invoices.convertedFromInvoiceId, proformaId))
+            .limit(1);
+        if (existing)
+            return { status: "already_converted", invoice: existing };
+        if (lockedProforma.status === "void") {
+            return { status: "already_converted", invoice: null };
+        }
+        const [duplicateFiscalInvoice] = await tx
+            .select({ id: invoices.id, invoiceNumber: invoices.invoiceNumber })
+            .from(invoices)
+            .where(and(eq(invoices.bookingId, lockedProforma.bookingId), eq(invoices.invoiceType, "invoice"), ne(invoices.status, "void"), eq(invoices.totalCents, lockedProforma.totalCents), eq(invoices.currency, lockedProforma.currency)))
+            .limit(1);
+        if (duplicateFiscalInvoice) {
+            return { status: "duplicate_fiscal_invoice", invoice: duplicateFiscalInvoice };
+        }
+        const lineItems = await tx
+            .select()
+            .from(invoiceLineItems)
+            .where(eq(invoiceLineItems.invoiceId, proformaId))
+            .orderBy(asc(invoiceLineItems.sortOrder));
+        const [inserted] = await tx
+            .insert(invoices)
+            .values({
+            invoiceNumber: newInvoiceNumber,
+            invoiceType: "invoice",
+            convertedFromInvoiceId: lockedProforma.id,
+            seriesId: lockedProforma.seriesId,
+            templateId: lockedProforma.templateId,
+            taxRegimeId: lockedProforma.taxRegimeId,
+            language: lockedProforma.language,
+            bookingId: lockedProforma.bookingId,
+            personId: lockedProforma.personId,
+            organizationId: lockedProforma.organizationId,
+            status: "issued",
+            currency: lockedProforma.currency,
+            baseCurrency: lockedProforma.baseCurrency,
+            fxRateSetId: lockedProforma.fxRateSetId,
+            subtotalCents: lockedProforma.subtotalCents,
+            baseSubtotalCents: lockedProforma.baseSubtotalCents,
+            taxCents: lockedProforma.taxCents,
+            baseTaxCents: lockedProforma.baseTaxCents,
+            totalCents: lockedProforma.totalCents,
+            baseTotalCents: lockedProforma.baseTotalCents,
+            // Carry the proforma's settled amounts forward — a partially
+            // (or fully) paid proforma must convert to an invoice that
+            // reflects those payments, otherwise the new invoice shows the
+            // full total as outstanding and the payment rows reassigned
+            // below would orphan the balance.
+            paidCents: lockedProforma.paidCents,
+            basePaidCents: lockedProforma.basePaidCents,
+            balanceDueCents: lockedProforma.totalCents - lockedProforma.paidCents,
+            baseBalanceDueCents: lockedProforma.baseTotalCents !== null && lockedProforma.basePaidCents !== null
+                ? lockedProforma.baseTotalCents - lockedProforma.basePaidCents
+                : lockedProforma.baseTotalCents,
+            commissionPercent: lockedProforma.commissionPercent,
+            commissionAmountCents: lockedProforma.commissionAmountCents,
+            issueDate,
+            dueDate,
+            notes: null,
+        })
+            .returning();
+        if (!inserted)
+            return { status: "not_found" };
+        if (lineItems.length > 0) {
+            await tx.insert(invoiceLineItems).values(lineItems.map((line) => ({
+                invoiceId: inserted.id,
+                bookingItemId: line.bookingItemId,
+                description: line.description,
+                quantity: line.quantity,
+                unitPriceCents: line.unitPriceCents,
+                totalCents: line.totalCents,
+                taxRate: line.taxRate,
+                sortOrder: line.sortOrder,
+            })));
+        }
+        // Reassign payments off the proforma so they don't sit attached to
+        // a void document. The proforma's payment rows become the final
+        // invoice's payment history.
+        await tx
+            .update(payments)
+            .set({ invoiceId: inserted.id, updatedAt: now })
+            .where(eq(payments.invoiceId, lockedProforma.id));
+        await tx
+            .update(invoices)
+            .set({
+            status: "void",
+            paidCents: 0,
+            basePaidCents: lockedProforma.basePaidCents == null ? null : 0,
+            balanceDueCents: 0,
+            baseBalanceDueCents: lockedProforma.baseBalanceDueCents == null ? null : 0,
+            voidedAt: now,
+            voidReason: `Converted to invoice ${inserted.invoiceNumber}`,
+            updatedAt: now,
+        })
+            .where(eq(invoices.id, lockedProforma.id));
+        return { status: "ok", invoice: inserted, proforma: lockedProforma };
+    })
+        .catch((error) => {
+        if (isInvoiceNumberUniqueConstraintError(error)) {
+            throw new InvoiceNumberConflictError(newInvoiceNumber);
+        }
+        throw error;
+    });
+    if (result.status !== "ok")
+        return result;
+    await emitProformaConverted(db, runtime, result.invoice, result.proforma);
+    return { status: "ok", invoice: result.invoice };
+}
+function deriveInvoiceNumberFromProforma(proformaNumber) {
+    if (/^PRO-/i.test(proformaNumber)) {
+        return proformaNumber.replace(/^PRO-/i, "INV-");
+    }
+    return `${proformaNumber}-INV`;
+}
+function buildClientName(booking) {
+    const name = [booking?.contactFirstName, booking?.contactLastName]
+        .filter((part) => typeof part === "string" && part.length > 0)
+        .join(" ");
+    return name || "Client";
+}
+function centsToMajor(cents) {
+    return cents / 100;
+}
+function toDateString(value) {
+    return typeof value === "string" ? value : value.toISOString().slice(0, 10);
+}