@voyant-travel/accommodations 0.105.17

package/dist/service-catalog-plane.js

@@ -0,0 +1,202 @@
+/**
+ * Catalog-plane integration for the accommodation service.
+ *
+ * The accommodation vertical's catalog entry is the **room type** — the
+ * sellable variant within a property. Properties live in
+ * `packages/facilities` and are referenced via `propertyId`.
+ *
+ * Mirrors the pattern in `packages/products/src/service-catalog-plane.ts`.
+ *
+ * See `docs/architecture/catalog-architecture.md` §9.1.
+ */
+import { buildIndexerDocument, buildSnapshotInputFromView, createFieldPolicyRegistry, resolveEntityView, } from "@voyant-travel/catalog";
+import { and, eq } from "drizzle-orm";
+import { accommodationCatalogPolicy } from "./catalog-policy.js";
+import { roomTypes } from "./schema-inventory.js";
+import { ACCOMMODATION_CONTENT_MARKET_ANY, accommodationSourcedContentTable, } from "./schema-sourced-content.js";
+let _registry;
+function getAccommodationRegistry() {
+    if (!_registry) {
+        _registry = createFieldPolicyRegistry(accommodationCatalogPolicy);
+    }
+    return _registry;
+}
+/**
+ * Maps a room-type row to a field-keyed projection. Provenance covers sourced
+ * and direct-supplier lodging inventory; the caller declares the source kind.
+ */
+export function roomTypeRowToProjection(row, context) {
+    return new Map([
+        // Provenance
+        ["source.kind", context.sourceKind ?? "direct"],
+        ["source.ref", context.sourceRef],
+        ["seller.operator_id", context.sellerOperatorId],
+        // Identity
+        ["id", row.id],
+        ["code", row.code],
+        ["createdAt", row.createdAt],
+        ["updatedAt", row.updatedAt],
+        // Cross-module reference
+        ["propertyId", row.propertyId],
+        ["supplierId", row.supplierId],
+        // Merchandisable
+        ["name", row.name],
+        ["description", row.description],
+        ["accessibilityNotes", row.accessibilityNotes],
+        ["thumbnailUrl", pickThumbnailUrl(row.metadata)],
+        // Structural / facets
+        ["inventoryMode", row.inventoryMode],
+        ["roomClass", row.roomClass],
+        ["active", row.active],
+        ["smokingAllowed", row.smokingAllowed],
+        ["sortOrder", row.sortOrder],
+        // Occupancy
+        ["maxAdults", row.maxAdults],
+        ["maxChildren", row.maxChildren],
+        ["maxInfants", row.maxInfants],
+        ["standardOccupancy", row.standardOccupancy],
+        ["maxOccupancy", row.maxOccupancy],
+        ["minOccupancy", row.minOccupancy],
+        // Physical
+        ["bedroomCount", row.bedroomCount],
+        ["bathroomCount", row.bathroomCount],
+        ["areaValue", row.areaValue],
+        ["areaUnit", row.areaUnit],
+    ]);
+}
+export function roomTypeProvenance(_row, context) {
+    return {
+        source_kind: context.sourceKind ?? "direct",
+        source_freshness: context.sourceKind && context.sourceKind !== "direct" ? "sync" : "static",
+        source_ref: context.sourceRef,
+    };
+}
+export async function getResolvedRoomTypeById(db, id, context) {
+    const rows = await db.select().from(roomTypes).where(eq(roomTypes.id, id)).limit(1);
+    const row = rows[0];
+    if (!row)
+        return null;
+    const projection = roomTypeRowToProjection(row, {
+        sellerOperatorId: context.sellerOperatorId,
+        sourceKind: context.sourceKind,
+        sourceRef: context.sourceRef,
+    });
+    return resolveEntityView(db, getAccommodationRegistry(), "accommodations", id, projection, context.scope);
+}
+export async function listResolvedRoomTypes(db, rows, context) {
+    const registry = getAccommodationRegistry();
+    const views = [];
+    for (const row of rows) {
+        const projection = roomTypeRowToProjection(row, {
+            sellerOperatorId: context.sellerOperatorId,
+            sourceKind: context.sourceKind,
+            sourceRef: context.sourceRef,
+        });
+        const view = await resolveEntityView(db, registry, "accommodations", row.id, projection, context.scope);
+        views.push(view);
+    }
+    return views;
+}
+/**
+ * Build a `CaptureSnapshotInput` for a accommodation room type. Used by
+ * booking commit flows to capture the room-type view at booking time.
+ */
+export async function buildRoomTypeSnapshotInput(db, roomTypeId, context) {
+    const view = await getResolvedRoomTypeById(db, roomTypeId, context);
+    if (!view)
+        return null;
+    return buildSnapshotInputFromView(view, {
+        entityModule: "accommodations",
+        entityId: roomTypeId,
+        sourceKind: context.sourceKind ?? "direct",
+        sourceRef: context.sourceRef,
+        pricingBasis: context.pricingBasis,
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Indexer document emission
+// ─────────────────────────────────────────────────────────────────────────────
+export function createRoomTypeDocumentEmitter(context) {
+    const registry = getAccommodationRegistry();
+    return {
+        vertical: "accommodations",
+        emit(source, slice) {
+            const projection = roomTypeRowToProjection(source, {
+                sellerOperatorId: context.sellerOperatorId,
+                sourceKind: context.sourceKind,
+                sourceRef: context.sourceRef,
+            });
+            return buildIndexerDocument(registry, projection, slice, source.id);
+        },
+    };
+}
+export function createRoomTypeDocumentBuilder(db, context) {
+    const registry = getAccommodationRegistry();
+    return async (entityId, slice) => {
+        const rows = await db.select().from(roomTypes).where(eq(roomTypes.id, entityId)).limit(1);
+        const row = rows[0];
+        if (!row)
+            return null;
+        const projection = new Map(roomTypeRowToProjection(row, {
+            sellerOperatorId: context.sellerOperatorId,
+            sourceKind: context.sourceKind,
+            sourceRef: context.sourceRef,
+        }));
+        const sourcedThumbnailUrl = await fetchSourcedContentThumbnailUrl(db, entityId, slice);
+        if (sourcedThumbnailUrl) {
+            projection.set("thumbnailUrl", sourcedThumbnailUrl);
+        }
+        return buildIndexerDocument(registry, projection, slice, entityId);
+    };
+}
+async function fetchSourcedContentThumbnailUrl(db, entityId, slice) {
+    const rows = await db
+        .select({
+        market: accommodationSourcedContentTable.market,
+        payload: accommodationSourcedContentTable.payload,
+    })
+        .from(accommodationSourcedContentTable)
+        .where(and(eq(accommodationSourcedContentTable.entity_id, entityId), eq(accommodationSourcedContentTable.locale, slice.locale)));
+    const row = rows.find((candidate) => candidate.market === slice.market) ??
+        rows.find((candidate) => candidate.market === ACCOMMODATION_CONTENT_MARKET_ANY) ??
+        rows[0];
+    return pickThumbnailUrl(row?.payload);
+}
+function pickThumbnailUrl(value) {
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    return (firstString(record.thumbnailUrl, record.heroImageUrl, record.hero_image_url, record.imageUrl, record.image_url) ??
+        firstMediaUrl(record.media) ??
+        firstStringFromArray(record.images) ??
+        firstStringFromArray(record.galleryUrls));
+}
+function firstMediaUrl(value) {
+    if (!Array.isArray(value))
+        return null;
+    for (const item of value) {
+        const media = asRecord(item);
+        if (!media)
+            continue;
+        const type = typeof media.type === "string" ? media.type : null;
+        if (type && type !== "image")
+            continue;
+        const url = firstString(media.url, media.src);
+        if (url)
+            return url;
+    }
+    return null;
+}
+function firstStringFromArray(value) {
+    if (!Array.isArray(value))
+        return null;
+    return value.find((item) => typeof item === "string" && item.length > 0) ?? null;
+}
+function firstString(...values) {
+    return (values.find((value) => typeof value === "string" && value.length > 0) ?? null);
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}

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

@@ -0,0 +1,13 @@
+import type { ContentLocaleMatchKind } from "@voyant-travel/catalog";
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { type AccommodationContent } from "./content-shape.js";
+export interface BuildOwnedAccommodationContentOptions {
+    preferredLocales: ReadonlyArray<string>;
+}
+export interface BuildOwnedAccommodationContentResult {
+    content: AccommodationContent;
+    servedLocale: string;
+    matchKind: ContentLocaleMatchKind;
+}
+export declare function buildOwnedAccommodationContent(db: AnyDrizzleDb, entityId: string, options: BuildOwnedAccommodationContentOptions): Promise<BuildOwnedAccommodationContentResult | null>;
+//# sourceMappingURL=service-content-owned.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-content-owned.d.ts","sourceRoot":"","sources":["../src/service-content-owned.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAQrD,OAAO,EACL,KAAK,oBAAoB,EAI1B,MAAM,oBAAoB,CAAA;AAS3B,MAAM,WAAW,qCAAqC;IACpD,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACxC;AAED,MAAM,WAAW,oCAAoC;IACnD,OAAO,EAAE,oBAAoB,CAAA;IAC7B,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,sBAAsB,CAAA;CAClC;AAED,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,YAAY,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,qCAAqC,GAC7C,OAAO,CAAC,oCAAoC,GAAG,IAAI,CAAC,CAsItD"}

package/dist/service-content-owned.js

@@ -0,0 +1,205 @@
+import { facilities, facilityAddressProjections, facilityFeatures, properties, } from "@voyant-travel/operations";
+import { and, asc, eq, inArray } from "drizzle-orm";
+import { accommodationContentSchema, validateAccommodationContent, } from "./content-shape.js";
+import { mealPlans, ratePlanRoomTypes, ratePlans, roomTypeBedConfigs, roomTypes, } from "./schema-inventory.js";
+export async function buildOwnedAccommodationContent(db, entityId, options) {
+    // biome-ignore lint/suspicious/noExplicitAny: AnyDrizzleDb widens drizzle's row inference. -- owner: accommodations; existing suppression is intentional pending typed cleanup.
+    const roomRow = (await db.select().from(roomTypes).where(eq(roomTypes.id, entityId)).limit(1))[0];
+    if (!roomRow)
+        return null;
+    // biome-ignore lint/suspicious/noExplicitAny: AnyDrizzleDb widens drizzle's row inference. -- owner: accommodations; existing suppression is intentional pending typed cleanup.
+    const propertyRow = (await db.select().from(properties).where(eq(properties.id, roomRow.propertyId)).limit(1))[0];
+    if (!propertyRow)
+        return null;
+    const ownedRows = await Promise.all([
+        db.select().from(facilities).where(eq(facilities.id, propertyRow.facilityId)).limit(1),
+        db
+            .select()
+            .from(facilityAddressProjections)
+            .where(eq(facilityAddressProjections.facilityId, propertyRow.facilityId))
+            .limit(1),
+        db
+            .select()
+            .from(facilityFeatures)
+            .where(eq(facilityFeatures.facilityId, propertyRow.facilityId))
+            .orderBy(asc(facilityFeatures.sortOrder), asc(facilityFeatures.name)),
+        db
+            .select()
+            .from(roomTypes)
+            .where(and(eq(roomTypes.propertyId, propertyRow.id), eq(roomTypes.active, true)))
+            .orderBy(asc(roomTypes.sortOrder), asc(roomTypes.name)),
+        db
+            .select()
+            .from(mealPlans)
+            .where(and(eq(mealPlans.propertyId, propertyRow.id), eq(mealPlans.active, true)))
+            .orderBy(asc(mealPlans.sortOrder), asc(mealPlans.name)),
+        db
+            .select()
+            .from(ratePlans)
+            .where(and(eq(ratePlans.propertyId, propertyRow.id), eq(ratePlans.active, true)))
+            .orderBy(asc(ratePlans.sortOrder), asc(ratePlans.name)),
+    ]);
+    const facilityRows = ownedRows[0];
+    const addressRows = ownedRows[1];
+    const featureRows = ownedRows[2];
+    const roomRows = ownedRows[3];
+    const mealPlanRows = ownedRows[4];
+    const ratePlanRows = ownedRows[5];
+    const roomIds = roomRows.map((row) => row.id);
+    const ratePlanIds = ratePlanRows.map((row) => row.id);
+    const [bedRows, ratePlanRoomRows] = await Promise.all([
+        roomIds.length > 0
+            ? db
+                .select()
+                .from(roomTypeBedConfigs)
+                .where(inArray(roomTypeBedConfigs.roomTypeId, roomIds))
+                .orderBy(asc(roomTypeBedConfigs.isPrimary), asc(roomTypeBedConfigs.createdAt))
+            : [],
+        ratePlanIds.length > 0
+            ? db
+                .select()
+                .from(ratePlanRoomTypes)
+                .where(and(inArray(ratePlanRoomTypes.ratePlanId, ratePlanIds), eq(ratePlanRoomTypes.active, true)))
+                .orderBy(asc(ratePlanRoomTypes.sortOrder), asc(ratePlanRoomTypes.createdAt))
+            : [],
+    ]);
+    const facilityRow = facilityRows[0] ?? null;
+    const addressRow = addressRows[0] ?? null;
+    const content = accommodationContentSchema.parse({
+        hotel: {
+            id: propertyRow.id,
+            name: facilityRow?.name ?? roomRow.name,
+            description: facilityRow?.description ?? roomRow.description ?? null,
+            star_rating: normalizeStarRating(propertyRow.rating, propertyRow.ratingScale),
+            hero_image_url: firstStringFromMetadata(roomRow.metadata, "images"),
+            highlights: featureRows
+                .filter((feature) => feature.highlighted)
+                .map((feature) => feature.name),
+            brand: propertyRow.brandName ?? propertyRow.groupName ?? null,
+            country: addressRow?.country ?? null,
+            city: addressRow?.city ?? null,
+            address: addressRow?.fullText ?? addressRow?.address ?? addressRow?.line1 ?? null,
+            postal_code: addressRow?.postalCode ?? null,
+            latitude: addressRow?.latitude ?? null,
+            longitude: addressRow?.longitude ?? null,
+            check_in_time: propertyRow.checkInTime ?? null,
+            check_out_time: propertyRow.checkOutTime ?? null,
+        },
+        room_types: roomRows.map((room) => ownedRoomTypeToContent(room, bedRows)),
+        rate_plans: ratePlanRows.map((plan) => ownedRatePlanToContent(plan, ratePlanRoomRows)),
+        meal_plans: mealPlanRows.map((plan) => ({
+            id: plan.id,
+            code: plan.code,
+            name: plan.name,
+            description: plan.description ?? null,
+            basis: mealPlanBasis(plan),
+            inclusions: mealPlanInclusions(plan),
+        })),
+        amenities: featureRows
+            .filter((feature) => feature.category === "amenity")
+            .map((feature) => ({
+            id: feature.code ?? feature.id,
+            category: feature.category,
+            name: feature.name,
+            description: feature.description ?? feature.valueText ?? null,
+            is_free: undefined,
+        })),
+        policies: propertyRow.policyNotes
+            ? [{ kind: "supplier_notes", body: propertyRow.policyNotes }]
+            : [],
+    });
+    const validation = validateAccommodationContent(content);
+    if (!validation.valid) {
+        throw new Error(`owned accommodation ${entityId} projection failed validation: ${validation.reason}`);
+    }
+    return {
+        content,
+        servedLocale: options.preferredLocales[0] ?? "en-GB",
+        matchKind: options.preferredLocales.length > 0 ? "exact" : "any",
+    };
+}
+function ownedRoomTypeToContent(room, bedRows) {
+    const roomBeds = bedRows.filter((bed) => bed.roomTypeId === room.id);
+    return {
+        id: room.id,
+        code: room.code ?? null,
+        name: room.name,
+        description: room.description ?? null,
+        room_class: room.roomClass ?? null,
+        view: stringFromMetadata(room.metadata, "view"),
+        bedrooms: room.bedroomCount ?? null,
+        beds: roomBeds.map((bed) => bed.quantity > 1 ? `${bed.quantity} ${bed.bedType}` : bed.bedType),
+        size_sqm: room.areaUnit === "sqm" ? room.areaValue : null,
+        max_adults: room.maxAdults ?? null,
+        max_children: room.maxChildren ?? null,
+        max_occupancy: room.maxOccupancy ?? room.standardOccupancy ?? null,
+        amenities: stringArrayFromMetadata(room.metadata, "amenities"),
+        images: stringArrayFromMetadata(room.metadata, "images"),
+    };
+}
+function ownedRatePlanToContent(plan, ratePlanRoomRows) {
+    return {
+        id: plan.id,
+        code: plan.code,
+        name: plan.name,
+        description: plan.description ?? null,
+        charge_frequency: contentChargeFrequency(plan.chargeFrequency),
+        applies_to_room_type_ids: ratePlanRoomRows
+            .filter((row) => row.ratePlanId === plan.id)
+            .map((row) => row.roomTypeId),
+        cancellation_policy: plan.cancellationPolicyId ?? null,
+        inclusions: [],
+    };
+}
+function contentChargeFrequency(value) {
+    return value === "per_stay" || value === "per_person_per_stay" ? "per_stay" : "per_night";
+}
+function mealPlanBasis(plan) {
+    if (plan.includesBreakfast && plan.includesLunch && plan.includesDinner && plan.includesDrinks) {
+        return "all_inclusive";
+    }
+    if (plan.includesBreakfast && plan.includesLunch && plan.includesDinner)
+        return "full_board";
+    if (plan.includesBreakfast && plan.includesDinner)
+        return "half_board";
+    if (plan.includesBreakfast)
+        return "bed_breakfast";
+    return "room_only";
+}
+function mealPlanInclusions(plan) {
+    const inclusions = [];
+    if (plan.includesBreakfast)
+        inclusions.push("Breakfast");
+    if (plan.includesLunch)
+        inclusions.push("Lunch");
+    if (plan.includesDinner)
+        inclusions.push("Dinner");
+    if (plan.includesDrinks)
+        inclusions.push("Drinks");
+    return inclusions;
+}
+function normalizeStarRating(value, scale) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    if (typeof scale === "number" && Number.isFinite(scale) && scale > 0 && scale !== 5) {
+        return Math.max(0, Math.min(5, (value / scale) * 5));
+    }
+    return Math.max(0, Math.min(5, value));
+}
+function firstStringFromMetadata(metadata, key) {
+    return stringArrayFromMetadata(metadata, key)[0] ?? null;
+}
+function stringArrayFromMetadata(metadata, key) {
+    if (!metadata || typeof metadata !== "object")
+        return [];
+    const value = metadata[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+function stringFromMetadata(metadata, key) {
+    if (!metadata || typeof metadata !== "object")
+        return null;
+    const value = metadata[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * Accommodation content synthesizer — fallback for thin adapters that
+ * declare `supportsContentFetch: false`.
+ *
+ * Produces the most complete `AccommodationContent` blob we can
+ * legitimately synthesize from the durable sourced-entry projection +
+ * locale-aware overlays + plane-level provenance. Fields the
+ * projection doesn't carry render as typed empty states (`room_types:
+ * []`, `rate_plans: []`).
+ *
+ * Per §3.6: never invents plausible-but-unverified fields ("hotels
+ * usually have a pool" is not a basis for an amenity), 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 AccommodationContent } from "./content-shape.js";
+export interface SynthesizeAccommodationContentOptions {
+    provenance: Extract<ProvenanceReadResult, {
+        kind: "sourced";
+    }>;
+    overlays?: ReadonlyArray<{
+        field_path: string;
+        value: unknown;
+    }>;
+}
+export interface SynthesizedAccommodationContent {
+    content: AccommodationContent;
+    content_schema_version: string;
+    served_locale: string;
+    source_kind: string;
+    source_provider?: string;
+}
+export declare function synthesizeAccommodationContent(scope: {
+    locale: string;
+}, options: SynthesizeAccommodationContentOptions): SynthesizedAccommodationContent;
+export declare function synthesizeAccommodationContentFromDb(db: AnyDrizzleDb, scope: {
+    locale: string;
+}, provenance: Extract<ProvenanceReadResult, {
+    kind: "sourced";
+}>): Promise<SynthesizedAccommodationContent>;
+//# 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;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,oBAAoB,CAAA;AAE3B,MAAM,WAAW,qCAAqC;IACpD,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,+BAA+B;IAC9C,OAAO,EAAE,oBAAoB,CAAA;IAC7B,sBAAsB,EAAE,MAAM,CAAA;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACzB,OAAO,EAAE,qCAAqC,GAC7C,+BAA+B,CAmCjC;AAED,wBAAsB,oCAAoC,CACxD,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,+BAA+B,CAAC,CAO1C"}

package/dist/service-content-synthesizer.js

@@ -0,0 +1,149 @@
+/**
+ * Accommodation content synthesizer — fallback for thin adapters that
+ * declare `supportsContentFetch: false`.
+ *
+ * Produces the most complete `AccommodationContent` blob we can
+ * legitimately synthesize from the durable sourced-entry projection +
+ * locale-aware overlays + plane-level provenance. Fields the
+ * projection doesn't carry render as typed empty states (`room_types:
+ * []`, `rate_plans: []`).
+ *
+ * Per §3.6: never invents plausible-but-unverified fields ("hotels
+ * usually have a pool" is not a basis for an amenity), never
+ * machine-translates, never mines snapshots, never caches its own
+ * output.
+ */
+import { fetchOverlaysForEntity, mergeOverlaysIntoContent, } from "@voyant-travel/catalog";
+import { ACCOMMODATION_CONTENT_SCHEMA_VERSION, accommodationContentSchema, } from "./content-shape.js";
+export function synthesizeAccommodationContent(scope, options) {
+    const projection = options.provenance.projection;
+    const hotel = pickHotelSummary(projection, options.provenance);
+    const amenities = pickAmenities(projection);
+    const policies = pickPolicies(projection);
+    const baseContent = {
+        hotel,
+        room_types: [],
+        rate_plans: [],
+        meal_plans: [],
+        amenities,
+        policies,
+    };
+    let merged = baseContent;
+    if (options.overlays && options.overlays.length > 0) {
+        const result = mergeOverlaysIntoContent(baseContent, options.overlays, {
+            validate(p) {
+                const r = accommodationContentSchema.safeParse(p);
+                return r.success
+                    ? { valid: true }
+                    : { valid: false, reason: r.error.issues[0]?.message ?? "invalid" };
+            },
+        });
+        merged = accommodationContentSchema.parse(result);
+    }
+    return {
+        content: merged,
+        content_schema_version: ACCOMMODATION_CONTENT_SCHEMA_VERSION,
+        served_locale: scope.locale,
+        source_kind: options.provenance.provenance.source_kind,
+        source_provider: options.provenance.provenance.source_provider,
+    };
+}
+export async function synthesizeAccommodationContentFromDb(db, scope, provenance) {
+    const entityId = entityIdFromProvenance(provenance);
+    const overlays = await fetchOverlaysForEntity(db, "accommodations", entityId);
+    return synthesizeAccommodationContent(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 pickHotelSummary(projection, provenance) {
+    return {
+        id: stringOr(projection.id, "") || provenance.entry_id,
+        name: stringOr(projection.name, "") || stringOr(projection.title, "") || "Unnamed property",
+        description: stringOr(projection.description, null),
+        star_rating: numberOr(projection.star_rating, null),
+        hero_image_url: stringOr(projection.hero_image_url, null),
+        highlights: stringArrayOr(projection.highlights, []),
+        brand: stringOr(projection.brand, null) ?? provenance.provenance.source_provider ?? null,
+        country: stringOr(projection.country, null),
+        city: stringOr(projection.city, null),
+        address: stringOr(projection.address, null),
+        postal_code: stringOr(projection.postal_code, null),
+        latitude: numberOr(projection.latitude, null),
+        longitude: numberOr(projection.longitude, null),
+        check_in_time: stringOr(projection.check_in_time, null),
+        check_out_time: stringOr(projection.check_out_time, null),
+    };
+}
+function pickAmenities(projection) {
+    // Bedbanks commonly emit a flat string array for amenities. We map
+    // each into the structured shape with no inferred category — that's
+    // genuinely unknown without a real getContent.
+    const list = projection.amenities;
+    if (!Array.isArray(list))
+        return [];
+    const out = [];
+    for (const item of list) {
+        if (typeof item === "string" && item.length > 0) {
+            out.push({
+                id: slugifyAmenityId(item),
+                category: null,
+                name: item,
+                description: null,
+            });
+        }
+        else if (item && typeof item === "object") {
+            const obj = item;
+            const name = stringOr(obj.name, null) ?? stringOr(obj.label, null);
+            if (!name)
+                continue;
+            out.push({
+                id: stringOr(obj.id, null) ?? slugifyAmenityId(name),
+                category: stringOr(obj.category, null),
+                name,
+                description: stringOr(obj.description, null),
+                is_free: typeof obj.is_free === "boolean" ? obj.is_free : undefined,
+            });
+        }
+    }
+    return out;
+}
+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 checkin = stringOr(projection.check_in_policy, null);
+    if (checkin)
+        out.push({ kind: "check_in", body: checkin });
+    return out;
+}
+function slugifyAmenityId(value) {
+    return (value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 64) || "amenity");
+}
+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;
+}

package/dist/service-content.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Accommodation content service — `getAccommodationContent` with locale-
+ * resolved cache reads, SWR refresh, and synthesizer fallback.
+ *
+ * Mirrors `service-content.ts` in the products and cruises packages
+ * but accommodation-shaped. The accommodation content aggregate (§3.2 /
+ * §3.6) is `{ hotel, room_types[], rate_plans[], meal_plans[],
+ * amenities[], policies[] }` — one payload returned by a single
+ * getContent. Pricing stays out (volatile-live, flows through
+ * `liveResolve`); rate plans here are the structural plan definitions,
+ * not their per-night rates.
+ */
+import { type ContentLocaleResolution, type InvalidateOnDrift, type SourceAdapter, type SourceAdapterContext } from "@voyant-travel/catalog";
+import type { SourceAdapterRegistry } from "@voyant-travel/catalog/booking-engine";
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { type AccommodationContent } from "./content-shape.js";
+export type { BuildOwnedAccommodationContentOptions, BuildOwnedAccommodationContentResult, } from "./service-content-owned.js";
+export { buildOwnedAccommodationContent } from "./service-content-owned.js";
+export interface AccommodationContentScope {
+    preferredLocales: ReadonlyArray<string>;
+    market?: string;
+    currency?: string;
+    acceptMachineTranslated?: boolean;
+}
+export interface GetAccommodationContentOptions {
+    registry: SourceAdapterRegistry;
+    buildAdapterContext?: (adapter: SourceAdapter) => SourceAdapterContext;
+    onOverlayError?: (event: {
+        field_path: string;
+        reason: string;
+    }) => void;
+}
+export interface ResolvedAccommodationContent {
+    content: AccommodationContent;
+    resolution: ContentLocaleResolution<{
+        locale: string;
+        payload: AccommodationContent;
+    }>;
+    source: "sourced-cache" | "sourced-fresh" | "synthesized" | "owned";
+    served_stale: boolean;
+    synthesized: boolean;
+    machine_translated: boolean;
+}
+export declare function getAccommodationContent(db: AnyDrizzleDb, entityId: string, scope: AccommodationContentScope, options: GetAccommodationContentOptions): Promise<ResolvedAccommodationContent | null>;
+/** Drift event consumer for the accommodation content cache. Per §3.4.1. */
+export declare const invalidateAccommodationContentOnDrift: InvalidateOnDrift;
+//# sourceMappingURL=service-content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-content.d.ts","sourceRoot":"","sources":["../src/service-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,KAAK,uBAAuB,EAK5B,KAAK,iBAAiB,EAKtB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAE1B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGrD,OAAO,EAEL,KAAK,oBAAoB,EAI1B,MAAM,oBAAoB,CAAA;AAY3B,YAAY,EACV,qCAAqC,EACrC,oCAAoC,GACrC,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAA;AAS3E,MAAM,WAAW,yBAAyB;IACxC,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACvC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAClC;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,qBAAqB,CAAA;IAC/B,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,oBAAoB,CAAA;IACtE,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CACzE;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,oBAAoB,CAAA;IAC7B,UAAU,EAAE,uBAAuB,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,oBAAoB,CAAA;KAAE,CAAC,CAAA;IACtF,MAAM,EAAE,eAAe,GAAG,eAAe,GAAG,aAAa,GAAG,OAAO,CAAA;IACnE,YAAY,EAAE,OAAO,CAAA;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,kBAAkB,EAAE,OAAO,CAAA;CAC5B;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,YAAY,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,yBAAyB,EAChC,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CA0I9C;AA6OD,4EAA4E;AAC5E,eAAO,MAAM,qCAAqC,EAAE,iBAGnD,CAAA"}