@voyant-travel/charters 0.117.2

package/dist/service-bookings.js

@@ -0,0 +1,267 @@
+import { bookingsService } from "@voyant-travel/bookings";
+import { bookingCharterDetailsService } from "./booking-extension.js";
+import { createCharterTravelers, generateCharterBookingNumber, priceCentsFromString, sourceRefEquals, } from "./service-bookings-helpers.js";
+import { createPerSuiteBooking, createWholeYachtBooking } from "./service-bookings-local.js";
+import { composePerSuiteQuote, composeWholeYachtQuote, } from "./service-pricing.js";
+// ---------- service ----------
+export const chartersBookingService = {
+    createPerSuiteBooking,
+    createWholeYachtBooking,
+    /**
+     * Create a per-suite booking against an external (adapter-sourced) voyage.
+     *
+     * 1. Fetch the upstream voyage + its suites; locate the matching suite and
+     *    compose a `PerSuiteQuote` locally from its multi-currency price columns.
+     * 2. Commit upstream BEFORE writing local rows so we can fail loudly if the
+     *    broker rejects the booking.
+     * 3. Inside a single transaction, create the local booking + travelers +
+     *    snapshot the quote into `booking_charter_details` with `source='external'`
+     *    and the upstream connectorBookingRef.
+     *
+     * If the upstream commit succeeds but the local insert fails, the upstream
+     * booking exists with no local trace — we surface the upstream ref in the
+     * thrown error so the operator can manually reconcile via the broker's UI.
+     */
+    async createExternalPerSuiteBooking(db, input, userId) {
+        if (input.guests.length < 1)
+            throw new Error("At least one guest is required");
+        const voyage = await input.adapter.fetchVoyage(input.voyageRef);
+        if (!voyage) {
+            throw new Error(`Adapter '${input.adapter.name}' has no voyage for sourceRef ${JSON.stringify(input.voyageRef)}`);
+        }
+        if (!voyage.bookingModes.includes("per_suite")) {
+            throw new Error(`External voyage ${voyage.voyageCode} does not offer per_suite bookings`);
+        }
+        const suites = await input.adapter.fetchVoyageSuites(input.voyageRef);
+        const suite = suites.find((s) => sourceRefEquals(s.sourceRef, input.suiteRef));
+        if (!suite) {
+            throw new Error(`Adapter '${input.adapter.name}' has no suite ${JSON.stringify(input.suiteRef)} on voyage ${voyage.voyageCode}`);
+        }
+        if (suite.maxGuests != null && input.guests.length > suite.maxGuests) {
+            throw new Error(`External suite ${suite.suiteCode} max guests is ${suite.maxGuests}; got ${input.guests.length}`);
+        }
+        const composed = composePerSuiteQuote({
+            voyageId: voyage.sourceRef.externalId,
+            suite: {
+                id: suite.sourceRef.externalId,
+                suiteName: suite.suiteName,
+                pricesByCurrency: suite.pricesByCurrency ?? {},
+                portFeesByCurrency: suite.portFeesByCurrency ?? {},
+            },
+            currency: input.currency,
+        });
+        const yacht = await input.adapter.fetchYacht(voyage.yachtRef);
+        // Commit upstream first — failure here means no local row is created.
+        const upstream = await input.adapter.createPerSuiteBooking({
+            voyageRef: input.voyageRef,
+            suiteRef: input.suiteRef,
+            currency: input.currency,
+            guests: input.guests,
+            contact: input.contact,
+            notes: input.notes ?? null,
+        });
+        const finalQuote = {
+            ...composed,
+            suitePrice: upstream.finalSuitePrice ?? composed.suitePrice,
+            portFee: upstream.finalPortFee !== undefined ? upstream.finalPortFee : composed.portFee,
+            total: upstream.finalTotal ?? composed.total,
+            currency: (upstream.finalCurrency ?? composed.currency),
+        };
+        return db.transaction(async (tx) => {
+            const bookingNumber = generateCharterBookingNumber("CHT");
+            const totalCents = priceCentsFromString(finalQuote.total);
+            const booking = await bookingsService.createBooking(tx, {
+                bookingNumber,
+                sellCurrency: finalQuote.currency,
+                status: "draft",
+                sourceType: "manual",
+                personId: input.personId ?? null,
+                organizationId: input.organizationId ?? null,
+                contactFirstName: input.contact.firstName,
+                contactLastName: input.contact.lastName,
+                contactEmail: input.contact.email ?? null,
+                contactPhone: input.contact.phone ?? null,
+                contactPreferredLanguage: input.contact.language ?? null,
+                contactCountry: input.contact.country ?? null,
+                contactRegion: input.contact.region ?? null,
+                contactCity: input.contact.city ?? null,
+                contactAddressLine1: input.contact.address ?? null,
+                contactPostalCode: input.contact.postalCode ?? null,
+                sellAmountCents: totalCents,
+                pax: input.guests.length,
+                startDate: voyage.departureDate,
+                endDate: voyage.returnDate,
+                internalNotes: input.notes ?? null,
+            }, userId);
+            if (!booking) {
+                throw new Error(`Upstream booking ${upstream.connectorBookingRef} succeeded but local createBooking returned null. Operator must reconcile manually via '${input.adapter.name}'.`);
+            }
+            await createCharterTravelers(tx, booking.id, input.guests, userId, {
+                includeGuestNotes: false,
+            });
+            const charterDetails = await bookingCharterDetailsService.upsert(tx, booking.id, {
+                bookingMode: "per_suite",
+                source: "external",
+                sourceProvider: input.adapter.name,
+                sourceRef: input.voyageRef,
+                voyageId: null,
+                suiteId: null,
+                yachtId: null,
+                voyageDisplayName: voyage.name ?? voyage.voyageCode,
+                suiteDisplayName: suite.suiteName,
+                yachtName: yacht?.name ?? null,
+                charterAreaSnapshot: voyage.charterAreaOverride ?? null,
+                guestCount: input.guests.length,
+                quotedCurrency: finalQuote.currency,
+                quotedSuitePrice: finalQuote.suitePrice,
+                quotedPortFee: finalQuote.portFee,
+                quotedCharterFee: null,
+                apaPercent: null,
+                apaAmount: null,
+                quotedTotal: finalQuote.total,
+                mybaTemplateIdSnapshot: null,
+                mybaContractId: null,
+                apaPaidAmount: null,
+                apaSpentAmount: null,
+                apaRefundAmount: null,
+                connectorBookingRef: upstream.connectorBookingRef,
+                connectorStatus: upstream.connectorStatus ?? null,
+                notes: input.notes ?? null,
+            });
+            return {
+                bookingId: booking.id,
+                bookingNumber: booking.bookingNumber,
+                charterDetails,
+                quote: finalQuote,
+                sourceProvider: input.adapter.name,
+                sourceRef: input.voyageRef,
+            };
+        });
+    },
+    /**
+     * Create a whole-yacht booking against an external (adapter-sourced) voyage.
+     *
+     * Same atomicity model as `createExternalPerSuiteBooking`. External
+     * whole-yacht bookings still require a Voyant-side MYBA template — the
+     * adapter must surface it via `voyage.mybaTemplateRefOverride` or
+     * `product.defaultMybaTemplateRef`. The string is stored as
+     * `mybaTemplateIdSnapshot` and the operator wires up an actual contract
+     * later via `mybaService.generateContract`.
+     */
+    async createExternalWholeYachtBooking(db, input, userId) {
+        const voyage = await input.adapter.fetchVoyage(input.voyageRef);
+        if (!voyage) {
+            throw new Error(`Adapter '${input.adapter.name}' has no voyage for sourceRef ${JSON.stringify(input.voyageRef)}`);
+        }
+        if (!voyage.bookingModes.includes("whole_yacht")) {
+            throw new Error(`External voyage ${voyage.voyageCode} does not offer whole_yacht bookings`);
+        }
+        // Resolve product (for default APA + default MYBA template ref).
+        const product = await input.adapter.fetchProduct(voyage.productRef);
+        const apaPercent = voyage.apaPercentOverride ?? product?.defaultApaPercent ?? null;
+        if (!apaPercent) {
+            throw new Error(`External voyage ${voyage.voyageCode} has no APA percent set (neither voyage override nor product default).`);
+        }
+        const mybaTemplateRef = voyage.mybaTemplateRefOverride ?? product?.defaultMybaTemplateRef ?? null;
+        if (!mybaTemplateRef) {
+            throw new Error(`External voyage ${voyage.voyageCode} cannot be booked whole-yacht: no MYBA template ref configured (neither voyage override nor product default).`);
+        }
+        const composed = composeWholeYachtQuote({
+            voyage: {
+                id: voyage.sourceRef.externalId,
+                wholeYachtPricesByCurrency: voyage.wholeYachtPricesByCurrency ?? {},
+                apaPercentOverride: voyage.apaPercentOverride ?? null,
+            },
+            productDefaultApaPercent: product?.defaultApaPercent ?? null,
+            currency: input.currency,
+        });
+        const yacht = await input.adapter.fetchYacht(voyage.yachtRef);
+        // Commit upstream first — failure rolls everything back without writing.
+        const upstream = await input.adapter.createWholeYachtBooking({
+            voyageRef: input.voyageRef,
+            currency: input.currency,
+            guests: input.guests,
+            contact: input.contact,
+            notes: input.notes ?? null,
+        });
+        const finalQuote = {
+            ...composed,
+            charterFee: upstream.finalCharterFee ?? composed.charterFee,
+            apaPercent: upstream.finalApaPercent ?? composed.apaPercent,
+            apaAmount: upstream.finalApaAmount ?? composed.apaAmount,
+            total: upstream.finalTotal ?? composed.total,
+            currency: (upstream.finalCurrency ?? composed.currency),
+        };
+        const guestCount = Math.max(1, input.guests?.length ?? 1);
+        return db.transaction(async (tx) => {
+            const bookingNumber = generateCharterBookingNumber("WYC");
+            const totalCents = priceCentsFromString(finalQuote.total);
+            const booking = await bookingsService.createBooking(tx, {
+                bookingNumber,
+                sellCurrency: finalQuote.currency,
+                status: "draft",
+                sourceType: "manual",
+                personId: input.personId ?? null,
+                organizationId: input.organizationId ?? null,
+                contactFirstName: input.contact.firstName,
+                contactLastName: input.contact.lastName,
+                contactEmail: input.contact.email ?? null,
+                contactPhone: input.contact.phone ?? null,
+                contactPreferredLanguage: input.contact.language ?? null,
+                contactCountry: input.contact.country ?? null,
+                contactRegion: input.contact.region ?? null,
+                contactCity: input.contact.city ?? null,
+                contactAddressLine1: input.contact.address ?? null,
+                contactPostalCode: input.contact.postalCode ?? null,
+                sellAmountCents: totalCents,
+                pax: guestCount,
+                startDate: voyage.departureDate,
+                endDate: voyage.returnDate,
+                internalNotes: input.notes ?? null,
+            }, userId);
+            if (!booking) {
+                throw new Error(`Upstream booking ${upstream.connectorBookingRef} succeeded but local createBooking returned null. Operator must reconcile manually via '${input.adapter.name}'.`);
+            }
+            await createCharterTravelers(tx, booking.id, input.guests ?? [], userId, {
+                includeGuestNotes: false,
+            });
+            const charterDetails = await bookingCharterDetailsService.upsert(tx, booking.id, {
+                bookingMode: "whole_yacht",
+                source: "external",
+                sourceProvider: input.adapter.name,
+                sourceRef: input.voyageRef,
+                voyageId: null,
+                suiteId: null,
+                yachtId: null,
+                voyageDisplayName: voyage.name ?? voyage.voyageCode,
+                suiteDisplayName: null,
+                yachtName: yacht?.name ?? null,
+                charterAreaSnapshot: voyage.charterAreaOverride ?? null,
+                guestCount,
+                quotedCurrency: finalQuote.currency,
+                quotedSuitePrice: null,
+                quotedPortFee: null,
+                quotedCharterFee: finalQuote.charterFee,
+                apaPercent: finalQuote.apaPercent,
+                apaAmount: finalQuote.apaAmount,
+                quotedTotal: finalQuote.total,
+                mybaTemplateIdSnapshot: mybaTemplateRef,
+                mybaContractId: null,
+                apaPaidAmount: "0.00",
+                apaSpentAmount: "0.00",
+                apaRefundAmount: "0.00",
+                connectorBookingRef: upstream.connectorBookingRef,
+                connectorStatus: upstream.connectorStatus ?? null,
+                notes: input.notes ?? null,
+            });
+            return {
+                bookingId: booking.id,
+                bookingNumber: booking.bookingNumber,
+                charterDetails,
+                quote: finalQuote,
+                sourceProvider: input.adapter.name,
+                sourceRef: input.voyageRef,
+            };
+        });
+    },
+};

package/dist/service-catalog-plane.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Catalog-plane integration for the charters service.
+ *
+ * Mirrors the products / cruises / accommodations pattern. Charters carry a
+ * couple of vertical-specific managed fields — `defaultMybaTemplateId` and
+ * `defaultApaPercent` — that participate in the snapshot at quote/book time.
+ *
+ * See `docs/architecture/catalog-architecture.md` §9.1 and
+ * `docs/architecture/charters-module.md`.
+ */
+import { type CaptureSnapshotInput, type DocumentBuilder, type DocumentEmitter, type IndexerDocument, type IndexerSlice, type PricingBasis, type Provenance, type ResolvedView, type ResolverScope } from "@voyant-travel/catalog";
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { charterProducts } from "./schema-core.js";
+/**
+ * Maps a charter-product row to a field-keyed projection. Most charters are
+ * operator-owned (yacht agencies typically own the inventory they sell);
+ * sourced charters from a brand's central booking system would carry their
+ * actual provenance.
+ */
+export declare function charterProductRowToProjection(row: typeof charterProducts.$inferSelect, context: {
+    sellerOperatorId: string;
+    sourceKind?: string;
+    sourceRef?: string;
+}): ReadonlyMap<string, unknown>;
+export declare function charterProvenance(_row: typeof charterProducts.$inferSelect, context: {
+    sellerOperatorId: string;
+    sourceKind?: string;
+    sourceRef?: string;
+}): Provenance;
+export interface CharterCatalogContext {
+    sellerOperatorId: string;
+    scope: ResolverScope;
+    sourceKind?: string;
+    sourceRef?: string;
+}
+export declare function getResolvedCharterById(db: AnyDrizzleDb, id: string, context: CharterCatalogContext): Promise<ResolvedView | null>;
+export declare function listResolvedCharters(db: AnyDrizzleDb, rows: ReadonlyArray<typeof charterProducts.$inferSelect>, context: CharterCatalogContext): Promise<ResolvedView[]>;
+/**
+ * Build a `CaptureSnapshotInput` for a charter product. Charters' MYBA
+ * template id and APA percent participate in the snapshot per the policy
+ * (snapshot mode `on-book` and `on-quote-and-book` respectively) — the
+ * resolved view already includes them, so no special handling needed here.
+ */
+export declare function buildCharterSnapshotInput(db: AnyDrizzleDb, charterProductId: string, context: CharterCatalogContext & {
+    pricingBasis?: PricingBasis;
+}): Promise<Omit<CaptureSnapshotInput, "bookingId"> | null>;
+export declare function createCharterDocumentEmitter(context: {
+    sellerOperatorId: string;
+    sourceKind?: string;
+    sourceRef?: string;
+}): DocumentEmitter<typeof charterProducts.$inferSelect>;
+export declare function createCharterDocumentBuilder(db: AnyDrizzleDb, context: {
+    sellerOperatorId: string;
+    sourceKind?: string;
+    sourceRef?: string;
+}): DocumentBuilder;
+export type { CaptureSnapshotInput, DocumentBuilder, DocumentEmitter, IndexerDocument, IndexerSlice, PricingBasis, Provenance, ResolvedView, ResolverScope, };
+//# sourceMappingURL=service-catalog-plane.d.ts.map

package/dist/service-catalog-plane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-catalog-plane.d.ts","sourceRoot":"","sources":["../src/service-catalog-plane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAGL,KAAK,oBAAoB,EAEzB,KAAK,eAAe,EACpB,KAAK,eAAe,EAEpB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAEnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAUlD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,OAAO,eAAe,CAAC,YAAY,EACxC,OAAO,EAAE;IAAE,gBAAgB,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7E,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAwC9B;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,eAAe,CAAC,YAAY,EACzC,OAAO,EAAE;IAAE,gBAAgB,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7E,UAAU,CAMZ;AAED,MAAM,WAAW,qBAAqB;IACpC,gBAAgB,EAAE,MAAM,CAAA;IACxB,KAAK,EAAE,aAAa,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAW9B;AAED,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,YAAY,EAChB,IAAI,EAAE,aAAa,CAAC,OAAO,eAAe,CAAC,YAAY,CAAC,EACxD,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,YAAY,EAAE,CAAC,CAoBzB;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,YAAY,EAChB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,qBAAqB,GAAG;IAAE,YAAY,CAAC,EAAE,YAAY,CAAA;CAAE,GAC/D,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,GAAG,IAAI,CAAC,CAUzD;AAMD,wBAAgB,4BAA4B,CAAC,OAAO,EAAE;IACpD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,eAAe,CAAC,OAAO,eAAe,CAAC,YAAY,CAAC,CAavD;AAED,wBAAgB,4BAA4B,CAC1C,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE;IAAE,gBAAgB,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7E,eAAe,CAYjB;AAED,YAAY,EACV,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,aAAa,GACd,CAAA"}

package/dist/service-catalog-plane.js

@@ -0,0 +1,145 @@
+/**
+ * Catalog-plane integration for the charters service.
+ *
+ * Mirrors the products / cruises / accommodations pattern. Charters carry a
+ * couple of vertical-specific managed fields — `defaultMybaTemplateId` and
+ * `defaultApaPercent` — that participate in the snapshot at quote/book time.
+ *
+ * See `docs/architecture/catalog-architecture.md` §9.1 and
+ * `docs/architecture/charters-module.md`.
+ */
+import { buildIndexerDocument, buildSnapshotInputFromView, createFieldPolicyRegistry, resolveEntityView, } from "@voyant-travel/catalog";
+import { eq } from "drizzle-orm";
+import { charterCatalogPolicy } from "./catalog-policy.js";
+import { charterProducts } from "./schema-core.js";
+let _registry;
+function getChartersRegistry() {
+    if (!_registry) {
+        _registry = createFieldPolicyRegistry(charterCatalogPolicy);
+    }
+    return _registry;
+}
+/**
+ * Maps a charter-product row to a field-keyed projection. Most charters are
+ * operator-owned (yacht agencies typically own the inventory they sell);
+ * sourced charters from a brand's central booking system would carry their
+ * actual provenance.
+ */
+export function charterProductRowToProjection(row, context) {
+    return new Map([
+        // Provenance
+        ["source.kind", context.sourceKind ?? "owned"],
+        ["source.ref", context.sourceRef],
+        ["seller.operator_id", context.sellerOperatorId],
+        // Identity
+        ["id", row.id],
+        ["slug", row.slug],
+        ["createdAt", row.createdAt],
+        ["updatedAt", row.updatedAt],
+        ["externalRefs", row.externalRefs],
+        // Merchandisable
+        ["name", row.name],
+        ["description", row.description],
+        ["shortDescription", row.shortDescription],
+        ["heroImageUrl", row.heroImageUrl],
+        ["thumbnailUrl", row.heroImageUrl],
+        ["mapImageUrl", row.mapImageUrl],
+        // Structural
+        ["status", row.status],
+        ["lineSupplierId", row.lineSupplierId],
+        ["defaultYachtId", row.defaultYachtId],
+        ["regions[]", row.regions],
+        ["themes[]", row.themes],
+        ["defaultBookingModes[]", row.defaultBookingModes],
+        // Charter-specific managed fields (legal-sensitive — captured in snapshot)
+        ["defaultMybaTemplateId", row.defaultMybaTemplateId],
+        ["defaultApaPercent", row.defaultApaPercent],
+        // Volatile-indexed
+        ["lowestPriceCachedAmount", row.lowestPriceCachedAmount],
+        ["lowestPriceCachedCurrency", row.lowestPriceCachedCurrency],
+        ["earliestVoyageCached", row.earliestVoyageCached],
+        ["latestVoyageCached", row.latestVoyageCached],
+    ]);
+}
+export function charterProvenance(_row, context) {
+    return {
+        source_kind: context.sourceKind ?? "owned",
+        source_freshness: context.sourceKind && context.sourceKind !== "owned" ? "sync" : "static",
+        source_ref: context.sourceRef,
+    };
+}
+export async function getResolvedCharterById(db, id, context) {
+    const rows = await db.select().from(charterProducts).where(eq(charterProducts.id, id)).limit(1);
+    const row = rows[0];
+    if (!row)
+        return null;
+    const projection = charterProductRowToProjection(row, {
+        sellerOperatorId: context.sellerOperatorId,
+        sourceKind: context.sourceKind,
+        sourceRef: context.sourceRef,
+    });
+    return resolveEntityView(db, getChartersRegistry(), "charters", id, projection, context.scope);
+}
+export async function listResolvedCharters(db, rows, context) {
+    const registry = getChartersRegistry();
+    const views = [];
+    for (const row of rows) {
+        const projection = charterProductRowToProjection(row, {
+            sellerOperatorId: context.sellerOperatorId,
+            sourceKind: context.sourceKind,
+            sourceRef: context.sourceRef,
+        });
+        const view = await resolveEntityView(db, registry, "charters", row.id, projection, context.scope);
+        views.push(view);
+    }
+    return views;
+}
+/**
+ * Build a `CaptureSnapshotInput` for a charter product. Charters' MYBA
+ * template id and APA percent participate in the snapshot per the policy
+ * (snapshot mode `on-book` and `on-quote-and-book` respectively) — the
+ * resolved view already includes them, so no special handling needed here.
+ */
+export async function buildCharterSnapshotInput(db, charterProductId, context) {
+    const view = await getResolvedCharterById(db, charterProductId, context);
+    if (!view)
+        return null;
+    return buildSnapshotInputFromView(view, {
+        entityModule: "charters",
+        entityId: charterProductId,
+        sourceKind: context.sourceKind ?? "owned",
+        sourceRef: context.sourceRef,
+        pricingBasis: context.pricingBasis,
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Indexer document emission
+// ─────────────────────────────────────────────────────────────────────────────
+export function createCharterDocumentEmitter(context) {
+    const registry = getChartersRegistry();
+    return {
+        vertical: "charters",
+        emit(source, slice) {
+            const projection = charterProductRowToProjection(source, {
+                sellerOperatorId: context.sellerOperatorId,
+                sourceKind: context.sourceKind,
+                sourceRef: context.sourceRef,
+            });
+            return buildIndexerDocument(registry, projection, slice, source.id);
+        },
+    };
+}
+export function createCharterDocumentBuilder(db, context) {
+    const emitter = createCharterDocumentEmitter(context);
+    return async (entityId, slice) => {
+        const rows = await db
+            .select()
+            .from(charterProducts)
+            .where(eq(charterProducts.id, entityId))
+            .limit(1);
+        const row = rows[0];
+        if (!row)
+            return null;
+        return emitter.emit(row, slice);
+    };
+}

package/dist/service-content-synthesizer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Charter content synthesizer — fallback for thin adapters that
+ * declare `supportsContentFetch: false`.
+ *
+ * Produces the most complete `CharterContent` blob we can legitimately
+ * synthesize from the durable sourced-entry projection + locale-aware
+ * overlays + plane-level provenance. Yacht spec, voyage list, suite
+ * map, and schedule_days render as typed empty states unless the
+ * projection genuinely carries them.
+ *
+ * Per §3.6: never invents plausible-but-unverified fields, never
+ * machine-translates, never mines snapshots, never caches its own
+ * output.
+ */
+import { type ProvenanceReadResult } from "@voyant-travel/catalog";
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { type CharterContent } from "./content-shape.js";
+export interface SynthesizeCharterContentOptions {
+    provenance: Extract<ProvenanceReadResult, {
+        kind: "sourced";
+    }>;
+    overlays?: ReadonlyArray<{
+        field_path: string;
+        value: unknown;
+    }>;
+}
+export interface SynthesizedCharterContent {
+    content: CharterContent;
+    content_schema_version: string;
+    served_locale: string;
+    source_kind: string;
+    source_provider?: string;
+}
+export declare function synthesizeCharterContent(scope: {
+    locale: string;
+}, options: SynthesizeCharterContentOptions): SynthesizedCharterContent;
+export declare function synthesizeCharterContentFromDb(db: AnyDrizzleDb, scope: {
+    locale: string;
+}, provenance: Extract<ProvenanceReadResult, {
+    kind: "sourced";
+}>): Promise<SynthesizedCharterContent>;
+//# sourceMappingURL=service-content-synthesizer.d.ts.map

package/dist/service-content-synthesizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-content-synthesizer.d.ts","sourceRoot":"","sources":["../src/service-content-synthesizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,oBAAoB,CAAA;AAE3B,MAAM,WAAW,+BAA+B;IAC9C,UAAU,EAAE,OAAO,CAAC,oBAAoB,EAAE;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IAC9D,QAAQ,CAAC,EAAE,aAAa,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CACjE;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,cAAc,CAAA;IACvB,sBAAsB,EAAE,MAAM,CAAA;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACzB,OAAO,EAAE,+BAA+B,GACvC,yBAAyB,CAmC3B;AAED,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACzB,UAAU,EAAE,OAAO,CAAC,oBAAoB,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC,GAC7D,OAAO,CAAC,yBAAyB,CAAC,CAOpC"}

package/dist/service-content-synthesizer.js

@@ -0,0 +1,122 @@
+/**
+ * Charter content synthesizer — fallback for thin adapters that
+ * declare `supportsContentFetch: false`.
+ *
+ * Produces the most complete `CharterContent` blob we can legitimately
+ * synthesize from the durable sourced-entry projection + locale-aware
+ * overlays + plane-level provenance. Yacht spec, voyage list, suite
+ * map, and schedule_days render as typed empty states unless the
+ * projection genuinely carries them.
+ *
+ * Per §3.6: never invents plausible-but-unverified fields, never
+ * machine-translates, never mines snapshots, never caches its own
+ * output.
+ */
+import { fetchOverlaysForEntity, mergeOverlaysIntoContent, } from "@voyant-travel/catalog";
+import { CHARTERS_CONTENT_SCHEMA_VERSION, charterContentSchema, } from "./content-shape.js";
+export function synthesizeCharterContent(scope, options) {
+    const projection = options.provenance.projection;
+    const charter = pickCharterSummary(projection, options.provenance);
+    const yacht = pickYacht(projection);
+    const policies = pickPolicies(projection);
+    const baseContent = {
+        charter,
+        yacht,
+        voyages: [],
+        suites: [],
+        schedule_days: [],
+        policies,
+    };
+    let merged = baseContent;
+    if (options.overlays && options.overlays.length > 0) {
+        const result = mergeOverlaysIntoContent(baseContent, options.overlays, {
+            validate(p) {
+                const r = charterContentSchema.safeParse(p);
+                return r.success
+                    ? { valid: true }
+                    : { valid: false, reason: r.error.issues[0]?.message ?? "invalid" };
+            },
+        });
+        merged = charterContentSchema.parse(result);
+    }
+    return {
+        content: merged,
+        content_schema_version: CHARTERS_CONTENT_SCHEMA_VERSION,
+        served_locale: scope.locale,
+        source_kind: options.provenance.provenance.source_kind,
+        source_provider: options.provenance.provenance.source_provider,
+    };
+}
+export async function synthesizeCharterContentFromDb(db, scope, provenance) {
+    const entityId = entityIdFromProvenance(provenance);
+    const overlays = await fetchOverlaysForEntity(db, "charters", entityId);
+    return synthesizeCharterContent(scope, {
+        provenance,
+        overlays: overlays.map((o) => ({ field_path: o.field_path, value: o.value })),
+    });
+}
+function entityIdFromProvenance(provenance) {
+    const fromProjection = provenance.projection.id;
+    if (typeof fromProjection === "string" && fromProjection.length > 0) {
+        return fromProjection;
+    }
+    return provenance.entry_id;
+}
+function pickCharterSummary(projection, provenance) {
+    return {
+        id: stringOr(projection.id, "") || provenance.entry_id,
+        name: stringOr(projection.name, "") || stringOr(projection.title, "") || "Unnamed charter",
+        status: stringOr(projection.status, undefined),
+        description: stringOr(projection.description, null),
+        charter_type: stringOr(projection.charter_type, null),
+        hero_image_url: stringOr(projection.hero_image_url, null),
+        highlights: stringArrayOr(projection.highlights, []),
+        cruising_area: stringOr(projection.cruising_area, null) ?? stringOr(projection.area, null),
+        base_port: stringOr(projection.base_port, null),
+        duration_nights: numberOr(projection.duration_nights, null),
+    };
+}
+function pickYacht(projection) {
+    const yachtName = stringOr(projection.yacht_name, null) ?? stringOr(projection.yacht, null);
+    if (!yachtName)
+        return null;
+    return {
+        name: yachtName,
+        description: stringOr(projection.yacht_description, null),
+        type: stringOr(projection.yacht_type, null),
+        length_meters: numberOr(projection.length_meters, null),
+        capacity_guests: numberOr(projection.capacity_guests, null),
+        capacity_crew: numberOr(projection.capacity_crew, null),
+        cabins: numberOr(projection.cabins, null),
+        year_built: numberOr(projection.year_built, null),
+        builder: stringOr(projection.builder, null),
+        flag: stringOr(projection.flag, null),
+        amenities: stringArrayOr(projection.yacht_amenities, []),
+        images: stringArrayOr(projection.yacht_images, []),
+    };
+}
+function pickPolicies(projection) {
+    const out = [];
+    const cancel = stringOr(projection.cancellation_policy, null);
+    if (cancel)
+        out.push({ kind: "cancellation", body: cancel });
+    const payment = stringOr(projection.payment_terms, null);
+    if (payment)
+        out.push({ kind: "payment", body: payment });
+    const apa = stringOr(projection.apa_terms, null);
+    if (apa)
+        out.push({ kind: "apa", body: apa });
+    return out;
+}
+function stringOr(value, fallback) {
+    return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function numberOr(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function stringArrayOr(value, fallback) {
+    if (!Array.isArray(value))
+        return fallback;
+    const out = value.filter((v) => typeof v === "string");
+    return out.length > 0 ? out : fallback;
+}