@voyant-travel/finance 0.119.5

package/dist/service-bookings-dual-create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-bookings-dual-create.d.ts","sourceRoot":"","sources":["../src/service-bookings-dual-create.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACtF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AACzD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EAGzB,MAAM,6BAA6B,CAAA;AAkBpC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAI5E,MAAM,WAAW,wBAAyB,SAAQ,qBAAqB;CAAG;AAE1E,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,EAAE,MAAM,CAAA;IACxB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,UAAU,EAAE,IAAI,CAAA;CACjB;AAID,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,SAAS,EAAE,mBAAmB,CAAA;IAC9B,KAAK,EAAE,YAAY,CAAA;IACnB,aAAa,EAAE,kBAAkB,CAAA;IACjC,eAAe,EAAE,kBAAkB,CAAA;CACpC;AAED,MAAM,MAAM,wBAAwB,GAChC;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,uBAAuB,CAAA;CAAE,GACjD;IACE,MAAM,EAAE,gBAAgB,GAAG,kBAAkB,CAAA;IAC7C,MAAM,EAAE,OAAO,CAAC,oBAAoB,EAAE;QAAE,MAAM,EAAE,IAAI,CAAA;KAAE,CAAC,CAAA;CACxD,CAAA;AAqBL;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,kBAAkB,EACtB,QAAQ,EAAE,sBAAsB,EAChC,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,wBAAwB,CAAA;CAC9B,GACL,OAAO,CAAC,wBAAwB,CAAC,CAkFnC"}

package/dist/service-bookings-dual-create.js

@@ -0,0 +1,131 @@
+import { bookingGroupsService } from "@voyant-travel/bookings";
+import { z } from "zod";
+import { bookingCreateSubSchema, createBooking, } from "./service-booking-create.js";
+// ---------- validation ----------
+/**
+ * Sub-booking input. Takes the full create payload minus `group
+ * Membership` — dual-create owns the group lifecycle (one new group, both
+ * bookings linked as members) so accepting a nested group override would
+ * just be an opportunity for the caller to desync.
+ */
+const dualSubBookingSchema = bookingCreateSubSchema;
+const dualCreateGroupSchema = z.object({
+    kind: z.enum(["shared_room", "other"]).default("shared_room"),
+    label: z.string().max(255).optional().nullable(),
+    optionUnitId: z.string().optional().nullable(),
+});
+export const dualCreateBookingSchema = z.object({
+    primary: dualSubBookingSchema,
+    secondary: dualSubBookingSchema,
+    group: dualCreateGroupSchema.default({ kind: "shared_room" }),
+});
+/**
+ * Thrown inside the outer tx to force drizzle to roll back both bookings +
+ * the group when one of the inner create calls returns non-ok.
+ * Drizzle doesn't abort on a non-throwing tx callback, so we convert the
+ * discriminated outcome into a throw here.
+ */
+class DualCreateAbort extends Error {
+    outcome;
+    constructor(outcome) {
+        super(outcome.status === "ok"
+            ? "dual-create aborted: ok (unexpected)"
+            : `dual-create aborted: ${outcome.status}:${outcome.reason.status}`);
+        this.outcome = outcome;
+        this.name = "DualCreateAbort";
+    }
+}
+// ---------- service ----------
+/**
+ * Create two bookings linked via a new `booking_group`, atomically. The
+ * canonical operator flow: two travelers book a shared room ("partaj"), each
+ * gets their own booking, and both are attached to a new shared_room group
+ * so subsequent payment / cancellation decisions can fan out across the
+ * pair.
+ *
+ * Transaction shape:
+ *  - Outer tx opens via `db.transaction`.
+ *  - Inner: two savepoint-scoped `createBooking(tx, ...)` calls — the
+ *    nested transactions drizzle opens use SAVEPOINTs, so partial failures
+ *    surface up to this layer as non-ok outcomes.
+ *  - If either fails, the outer tx throws `DualCreateAbort` so the whole
+ *    thing rolls back (no orphan booking, no orphan group).
+ *  - Group creation + both memberships run last, inside the same outer tx.
+ *
+ * Event emission (`booking.dual-created`) is post-commit — subscribers only
+ * hear about successful pairs.
+ */
+export async function dualCreateBooking(db, rawInput, options = {}) {
+    const { userId, runtime } = options;
+    const input = dualCreateBookingSchema.parse(rawInput);
+    let result;
+    try {
+        result = await db.transaction(async (tx) => {
+            const primaryOutcome = await createBooking(tx, input.primary, { userId, runtime });
+            if (primaryOutcome.status !== "ok") {
+                throw new DualCreateAbort({ status: "primary_failed", reason: primaryOutcome });
+            }
+            const secondaryOutcome = await createBooking(tx, input.secondary, { userId, runtime });
+            if (secondaryOutcome.status !== "ok") {
+                throw new DualCreateAbort({ status: "secondary_failed", reason: secondaryOutcome });
+            }
+            const primaryBooking = primaryOutcome.result.booking;
+            const secondaryBooking = secondaryOutcome.result.booking;
+            const group = await bookingGroupsService.createBookingGroup(tx, {
+                kind: input.group.kind,
+                label: input.group.label ??
+                    `Shared — ${primaryBooking.bookingNumber} + ${secondaryBooking.bookingNumber}`,
+                productId: input.primary.productId,
+                optionUnitId: input.group.optionUnitId ?? null,
+                primaryBookingId: primaryBooking.id,
+            });
+            const primaryMemberResult = await bookingGroupsService.addGroupMember(tx, group.id, {
+                bookingId: primaryBooking.id,
+                role: "primary",
+            });
+            if (primaryMemberResult.status !== "ok") {
+                // Shouldn't happen — we just created both rows in this tx — but bail
+                // through the same abort path to unwind cleanly.
+                throw new DualCreateAbort({
+                    status: "primary_failed",
+                    reason: { status: "group_not_found" },
+                });
+            }
+            const secondaryMemberResult = await bookingGroupsService.addGroupMember(tx, group.id, {
+                bookingId: secondaryBooking.id,
+                role: "shared",
+            });
+            if (secondaryMemberResult.status !== "ok") {
+                throw new DualCreateAbort({
+                    status: "secondary_failed",
+                    reason: { status: "group_not_found" },
+                });
+            }
+            return {
+                primary: primaryOutcome.result,
+                secondary: secondaryOutcome.result,
+                group,
+                primaryMember: primaryMemberResult.member,
+                secondaryMember: secondaryMemberResult.member,
+            };
+        });
+    }
+    catch (error) {
+        if (error instanceof DualCreateAbort) {
+            return error.outcome;
+        }
+        throw error;
+    }
+    if (runtime?.eventBus) {
+        const event = {
+            groupId: result.group.id,
+            primaryBookingId: result.primary.booking.id,
+            secondaryBookingId: result.secondary.booking.id,
+            productId: input.primary.productId,
+            createdByUserId: userId ?? null,
+            occurredAt: new Date(),
+        };
+        await runtime.eventBus.emit("booking.dual-created", event);
+    }
+    return { status: "ok", result };
+}

package/dist/service-boundary-sql.d.ts

@@ -0,0 +1,6 @@
+import { type SQL } from "drizzle-orm";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export declare function executeBoundaryRows<T extends object>(db: PostgresJsDatabase, query: SQL): Promise<T[]>;
+export declare function sqlList(values: readonly string[]): SQL;
+export declare function normalizeDateOnly(value: Date | string | null | undefined): string | null;
+//# sourceMappingURL=service-boundary-sql.d.ts.map

package/dist/service-boundary-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-boundary-sql.d.ts","sourceRoot":"","sources":["../src/service-boundary-sql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAO,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,wBAAsB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EACxD,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,GAAG,GACT,OAAO,CAAC,CAAC,EAAE,CAAC,CAId;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,CAMtD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAGxF"}

package/dist/service-boundary-sql.js

@@ -0,0 +1,15 @@
+import { sql } from "drizzle-orm";
+export async function executeBoundaryRows(db, query) {
+    // biome-ignore lint/suspicious/noExplicitAny: #1141 keeps cross-package SQL boundary reads driver-agnostic.
+    const result = await db.execute(query);
+    return (Array.isArray(result) ? result : (result?.rows ?? []));
+}
+export function sqlList(values) {
+    // agent-quality: raw-sql reviewed -- owner: finance; callers pass only parameter-bound scalar ids into the joined SQL fragment.
+    return sql.join(values.map((value) => sql `${value}`), sql `, `);
+}
+export function normalizeDateOnly(value) {
+    if (!value)
+        return null;
+    return value instanceof Date ? value.toISOString().slice(0, 10) : value.slice(0, 10);
+}

package/dist/service-cost-categories.d.ts

@@ -0,0 +1,26 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export interface CostCategoryRecord {
+    id: string;
+    name: string;
+    sortOrder: number;
+    archived: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const costCategoriesService: {
+    list(db: PostgresJsDatabase, options?: {
+        includeArchived?: boolean;
+    }): Promise<CostCategoryRecord[]>;
+    create(db: PostgresJsDatabase, input: {
+        name: string;
+        sortOrder?: number;
+    }): Promise<CostCategoryRecord>;
+    update(db: PostgresJsDatabase, id: string, input: {
+        name?: string;
+        sortOrder?: number;
+        archived?: boolean;
+    }): Promise<CostCategoryRecord | null>;
+    /** Resolve id → name for a set of category ids (for breakdown labelling). */
+    nameMap(db: PostgresJsDatabase, ids: string[]): Promise<Map<string, string>>;
+};
+//# sourceMappingURL=service-cost-categories.d.ts.map

package/dist/service-cost-categories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-cost-categories.d.ts","sourceRoot":"","sources":["../src/service-cost-categories.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAkBjE,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAaD,eAAO,MAAM,qBAAqB;aAE1B,kBAAkB,YACb;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GACrC,OAAO,CAAC,kBAAkB,EAAE,CAAC;eAiB1B,kBAAkB,SACf;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAC1C,OAAO,CAAC,kBAAkB,CAAC;eAUxB,kBAAkB,MAClB,MAAM,SACH;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/D,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAarC,6EAA6E;gBAC3D,kBAAkB,OAAO,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CASnF,CAAA"}

package/dist/service-cost-categories.js

@@ -0,0 +1,76 @@
+import { asc, eq, isNull, sql } from "drizzle-orm";
+import { costCategories } from "./schema.js";
+/**
+ * Operator-configurable cost categories. Used to classify supplier-invoice
+ * lines and drive the per-category cost breakdown. Seeded lazily with sensible
+ * defaults the first time the list is read, so a fresh operator already has
+ * transportation / accommodation / guides / other to pick from.
+ */
+const DEFAULT_CATEGORIES = [
+    "Transportation",
+    "Accommodation",
+    "Guides / touristic services",
+    "Other",
+];
+function toRecord(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        sortOrder: row.sortOrder,
+        archived: row.archivedAt != null,
+        createdAt: row.createdAt.toISOString(),
+        updatedAt: row.updatedAt.toISOString(),
+    };
+}
+export const costCategoriesService = {
+    async list(db, options = {}) {
+        const existing = await db.select().from(costCategories);
+        if (existing.length === 0) {
+            await db
+                .insert(costCategories)
+                .values(DEFAULT_CATEGORIES.map((name, index) => ({ name, sortOrder: index })))
+                .onConflictDoNothing();
+        }
+        const rows = await db
+            .select()
+            .from(costCategories)
+            .where(options.includeArchived ? undefined : isNull(costCategories.archivedAt))
+            .orderBy(asc(costCategories.sortOrder), asc(costCategories.name));
+        return rows.map(toRecord);
+    },
+    async create(db, input) {
+        const [row] = await db
+            .insert(costCategories)
+            .values({ name: input.name.trim(), sortOrder: input.sortOrder ?? 0 })
+            .returning();
+        if (!row)
+            throw new Error("Failed to create cost category");
+        return toRecord(row);
+    },
+    async update(db, id, input) {
+        const patch = { updatedAt: new Date() };
+        if (input.name !== undefined)
+            patch.name = input.name.trim();
+        if (input.sortOrder !== undefined)
+            patch.sortOrder = input.sortOrder;
+        if (input.archived !== undefined)
+            patch.archivedAt = input.archived ? new Date() : null;
+        const [row] = await db
+            .update(costCategories)
+            .set(patch)
+            .where(eq(costCategories.id, id))
+            .returning();
+        return row ? toRecord(row) : null;
+    },
+    /** Resolve id → name for a set of category ids (for breakdown labelling). */
+    async nameMap(db, ids) {
+        if (ids.length === 0)
+            return new Map();
+        const rows = await db
+            .select({ id: costCategories.id, name: costCategories.name })
+            .from(costCategories)
+            // agent-quality: raw-sql reviewed -- owner: finance; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            .where(sql `${costCategories.id} = any(${ids})`);
+        return new Map(rows.map((r) => [r.id, r.name]));
+    },
+};

package/dist/service-documents.d.ts

@@ -0,0 +1,80 @@
+import type { EventBus } from "@voyant-travel/core";
+import type { StorageProvider, StorageUploadBody } from "@voyant-travel/storage";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type invoiceLineItems, type invoiceRenditions, type invoices, invoiceTemplates, type payments } from "./schema.js";
+import type { GenerateInvoiceDocumentInput } from "./validation.js";
+export interface GeneratedInvoiceRenditionArtifact {
+    format?: "html" | "pdf" | "xml" | "json";
+    storageKey?: string | null;
+    contentType?: string | null;
+    fileSize?: number | null;
+    checksum?: string | null;
+    language?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export interface InvoiceDocumentGeneratorContext {
+    db: PostgresJsDatabase;
+    invoice: typeof invoices.$inferSelect;
+    template: typeof invoiceTemplates.$inferSelect | null;
+    lineItems: Array<typeof invoiceLineItems.$inferSelect>;
+    payments: Array<typeof payments.$inferSelect>;
+    renderedBody: string;
+    renderedBodyFormat: "html" | "markdown" | "lexical_json";
+    variables: Record<string, unknown>;
+    bindings: Record<string, unknown>;
+    targetFormat: "html" | "pdf" | "xml" | "json";
+    language: string | null;
+}
+export type InvoiceDocumentGenerator = (context: InvoiceDocumentGeneratorContext) => Promise<GeneratedInvoiceRenditionArtifact>;
+export interface InvoiceDocumentRuntimeOptions {
+    bindings?: Record<string, unknown>;
+    generator: InvoiceDocumentGenerator;
+    eventBus?: EventBus;
+}
+export interface StorageBackedInvoiceDocumentUpload {
+    body: StorageUploadBody;
+    format?: "html" | "pdf" | "xml" | "json";
+    key?: string | null;
+    metadata?: Record<string, unknown> | null;
+    language?: string | null;
+}
+export type StorageBackedInvoiceDocumentSerializer = (context: InvoiceDocumentGeneratorContext) => Promise<StorageBackedInvoiceDocumentUpload> | StorageBackedInvoiceDocumentUpload;
+export interface StorageBackedInvoiceDocumentGeneratorOptions {
+    storage: StorageProvider;
+    keyPrefix?: string | ((context: InvoiceDocumentGeneratorContext) => Promise<string> | string);
+    serializer?: StorageBackedInvoiceDocumentSerializer;
+}
+export interface GeneratedInvoiceDocumentRecord {
+    invoiceId: string;
+    renderedBodyFormat: "html" | "markdown" | "lexical_json";
+    renderedBody: string;
+    rendition: typeof invoiceRenditions.$inferSelect;
+}
+export interface InvoiceDocumentGeneratedEvent {
+    invoiceId: string;
+    invoiceStatus: (typeof invoices.$inferSelect)["status"];
+    invoiceType: (typeof invoices.$inferSelect)["invoiceType"];
+    renditionId: string;
+    format: (typeof invoiceRenditions.$inferSelect)["format"];
+    renderedBodyFormat: "html" | "markdown" | "lexical_json";
+    regenerated: boolean;
+}
+export declare function defaultStorageBackedInvoiceDocumentSerializer(context: InvoiceDocumentGeneratorContext): Promise<StorageBackedInvoiceDocumentUpload> | StorageBackedInvoiceDocumentUpload;
+export declare function defaultPdfInvoiceDocumentSerializer(context: InvoiceDocumentGeneratorContext): Promise<StorageBackedInvoiceDocumentUpload>;
+export declare function createStorageBackedInvoiceDocumentGenerator(options: StorageBackedInvoiceDocumentGeneratorOptions): InvoiceDocumentGenerator;
+export declare function createPdfInvoiceDocumentGenerator(options: Omit<StorageBackedInvoiceDocumentGeneratorOptions, "serializer">): InvoiceDocumentGenerator;
+export declare const financeDocumentsService: {
+    generateInvoiceDocument(db: PostgresJsDatabase, invoiceId: string, input: GenerateInvoiceDocumentInput, runtime: InvoiceDocumentRuntimeOptions, options?: {
+        regenerated?: boolean;
+    }): Promise<{
+        status: "not_found" | "generator_failed";
+    } | ({
+        status: "generated";
+    } & GeneratedInvoiceDocumentRecord)>;
+    regenerateInvoiceDocument(db: PostgresJsDatabase, invoiceId: string, input: GenerateInvoiceDocumentInput, runtime: InvoiceDocumentRuntimeOptions): Promise<{
+        status: "not_found" | "generator_failed";
+    } | ({
+        status: "generated";
+    } & GeneratedInvoiceDocumentRecord)>;
+};
+//# sourceMappingURL=service-documents.d.ts.map

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

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

package/dist/service-documents.js

@@ -0,0 +1,228 @@
+import { renderPdfDocument } from "@voyant-travel/utils/pdf-renderer";
+import { and, desc, eq } from "drizzle-orm";
+import { invoiceTemplates, } from "./schema.js";
+import { financeService, renderInvoiceBody } from "./service.js";
+function defaultInvoiceDocumentMimeType(format) {
+    switch (format) {
+        case "html":
+            return "text/html; charset=utf-8";
+        case "json":
+            return "application/json; charset=utf-8";
+        case "xml":
+            return "application/xml; charset=utf-8";
+        default:
+            return "application/pdf";
+    }
+}
+function encodeStringBody(value) {
+    return new TextEncoder().encode(value);
+}
+function getBodySize(body) {
+    if (body instanceof Uint8Array)
+        return body.byteLength;
+    if (body instanceof ArrayBuffer)
+        return body.byteLength;
+    return body.size;
+}
+function toUploadMetadata(metadata) {
+    const entries = Object.entries(metadata ?? {}).filter(([, value]) => ["string", "number", "boolean"].includes(typeof value));
+    return entries.length > 0
+        ? Object.fromEntries(entries.map(([key, value]) => [key, String(value)]))
+        : undefined;
+}
+export function defaultStorageBackedInvoiceDocumentSerializer(context) {
+    switch (context.targetFormat) {
+        case "html":
+            return {
+                body: encodeStringBody(context.renderedBody),
+                format: "html",
+                language: context.language,
+                metadata: { renderedBodyFormat: context.renderedBodyFormat },
+            };
+        case "json":
+            return {
+                body: encodeStringBody(JSON.stringify(context.variables, null, 2)),
+                format: "json",
+                language: context.language,
+                metadata: { renderedBodyFormat: context.renderedBodyFormat },
+            };
+        case "xml":
+            return {
+                body: encodeStringBody(context.renderedBody),
+                format: "xml",
+                language: context.language,
+                metadata: { renderedBodyFormat: context.renderedBodyFormat },
+            };
+        default:
+            return defaultPdfInvoiceDocumentSerializer(context);
+    }
+}
+export async function defaultPdfInvoiceDocumentSerializer(context) {
+    const body = await renderPdfDocument({
+        title: `Invoice ${context.invoice.id}`,
+        content: context.renderedBody,
+        format: context.renderedBodyFormat === "lexical_json"
+            ? "lexical_json"
+            : context.renderedBodyFormat === "html"
+                ? "html"
+                : "markdown",
+        metadataLines: [
+            `Invoice ID: ${context.invoice.id}`,
+            ...(context.language ? [`Language: ${context.language}`] : []),
+        ],
+    });
+    return {
+        body,
+        format: "pdf",
+        language: context.language,
+        metadata: {
+            renderedBodyFormat: context.renderedBodyFormat,
+            renderer: "voyant-basic-pdf",
+        },
+    };
+}
+export function createStorageBackedInvoiceDocumentGenerator(options) {
+    const serializer = options.serializer ?? defaultStorageBackedInvoiceDocumentSerializer;
+    return async (context) => {
+        const upload = await serializer(context);
+        const format = upload.format ?? context.targetFormat;
+        const keyPrefix = typeof options.keyPrefix === "function"
+            ? await options.keyPrefix(context)
+            : (options.keyPrefix ?? `invoices/${context.invoice.id}`);
+        const key = upload.key?.trim() || `${keyPrefix.replace(/\/$/, "")}/rendition.${format}`;
+        const uploaded = await options.storage.upload(upload.body, {
+            key,
+            contentType: defaultInvoiceDocumentMimeType(format),
+            metadata: toUploadMetadata(upload.metadata),
+        });
+        return {
+            format,
+            storageKey: uploaded.key,
+            contentType: defaultInvoiceDocumentMimeType(format),
+            fileSize: getBodySize(upload.body),
+            language: upload.language ?? context.language,
+            metadata: {
+                ...(upload.metadata ?? {}),
+                storageProvider: options.storage.name,
+                ...(uploaded.url ? { url: uploaded.url } : {}),
+            },
+        };
+    };
+}
+export function createPdfInvoiceDocumentGenerator(options) {
+    return createStorageBackedInvoiceDocumentGenerator({
+        ...options,
+        serializer: defaultPdfInvoiceDocumentSerializer,
+    });
+}
+async function prepareInvoiceDocument(db, invoiceId, input) {
+    const invoice = await financeService.getInvoiceById(db, invoiceId);
+    if (!invoice) {
+        return { status: "not_found" };
+    }
+    let templateId = input.templateId ?? invoice.templateId ?? null;
+    if (!templateId) {
+        const [defaultTemplate] = await db
+            .select()
+            .from(invoiceTemplates)
+            .where(and(eq(invoiceTemplates.isDefault, true), eq(invoiceTemplates.active, true)))
+            .orderBy(desc(invoiceTemplates.updatedAt))
+            .limit(1);
+        templateId = defaultTemplate?.id ?? null;
+    }
+    const [template, lineItems, paymentRows] = await Promise.all([
+        templateId ? financeService.getInvoiceTemplateById(db, templateId) : Promise.resolve(null),
+        financeService.listInvoiceLineItems(db, invoiceId),
+        financeService.listPayments(db, invoiceId),
+    ]);
+    const renderedBodyFormat = template?.bodyFormat ?? "html";
+    const variables = {
+        invoice,
+        lineItems,
+        payments: paymentRows,
+    };
+    const renderedBody = template
+        ? renderInvoiceBody(template.body, template.bodyFormat, variables)
+        : JSON.stringify(variables);
+    return {
+        status: "ready",
+        invoice,
+        template,
+        lineItems,
+        payments: paymentRows,
+        renderedBody,
+        renderedBodyFormat,
+        variables,
+        targetFormat: input.format,
+        language: input.language ?? invoice.language ?? template?.language ?? null,
+    };
+}
+export const financeDocumentsService = {
+    async generateInvoiceDocument(db, invoiceId, input, runtime, options = {}) {
+        const prepared = await prepareInvoiceDocument(db, invoiceId, input);
+        if (prepared.status === "not_found") {
+            return { status: "not_found" };
+        }
+        let artifact;
+        try {
+            artifact = await runtime.generator({
+                db,
+                invoice: prepared.invoice,
+                template: prepared.template,
+                lineItems: prepared.lineItems,
+                payments: prepared.payments,
+                renderedBody: prepared.renderedBody,
+                renderedBodyFormat: prepared.renderedBodyFormat,
+                variables: prepared.variables,
+                bindings: runtime.bindings ?? {},
+                targetFormat: prepared.targetFormat,
+                language: prepared.language,
+            });
+        }
+        catch {
+            return { status: "generator_failed" };
+        }
+        const format = artifact.format ?? prepared.targetFormat;
+        const bindResult = await financeService.bindInvoiceRendition(db, invoiceId, {
+            templateId: prepared.template?.id ?? null,
+            format,
+            storageKey: artifact.storageKey?.trim() || null,
+            contentType: artifact.contentType ?? defaultInvoiceDocumentMimeType(format),
+            fileSize: artifact.fileSize ?? null,
+            checksum: artifact.checksum ?? null,
+            language: artifact.language ?? prepared.language ?? null,
+            generatedAt: new Date().toISOString(),
+            metadata: {
+                ...(artifact.metadata ?? {}),
+                renderedBodyFormat: prepared.renderedBodyFormat,
+            },
+            replaceExisting: input.replaceExisting,
+        }, { eventBus: runtime.eventBus });
+        if (bindResult.status !== "bound") {
+            return { status: "not_found" };
+        }
+        const { rendition } = bindResult;
+        await runtime.eventBus?.emit("invoice.document.generated", {
+            invoiceId: prepared.invoice.id,
+            invoiceStatus: prepared.invoice.status,
+            invoiceType: prepared.invoice.invoiceType,
+            renditionId: rendition.id,
+            format: rendition.format,
+            renderedBodyFormat: prepared.renderedBodyFormat,
+            regenerated: options.regenerated ?? false,
+        }, {
+            category: "internal",
+            source: "service",
+        });
+        return {
+            status: "generated",
+            invoiceId: prepared.invoice.id,
+            renderedBodyFormat: prepared.renderedBodyFormat,
+            renderedBody: prepared.renderedBody,
+            rendition,
+        };
+    },
+    async regenerateInvoiceDocument(db, invoiceId, input, runtime) {
+        return this.generateInvoiceDocument(db, invoiceId, input, runtime, { regenerated: true });
+    },
+};