@voyantjs/accommodations 0.55.0

package/dist/service-content.js

@@ -0,0 +1,480 @@
+/**
+ * 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 { createInvalidateOnDrift, fetchOverlaysForEntity, isStale, pickBestCachedLocale, readSourcedEntry, withContentRefreshLock, } from "@voyantjs/catalog";
+import { facilities, facilityAddressProjections, facilityFeatures, properties, } from "@voyantjs/facilities/schema";
+import { and, asc, eq, inArray } from "drizzle-orm";
+import { ACCOMMODATION_CONTENT_SCHEMA_VERSION, accommodationContentSchema, mergeOverlaysIntoAccommodationContent, validateAccommodationContent, } from "./content-shape.js";
+import { mealPlans, ratePlanRoomTypes, ratePlans, roomTypeBedConfigs, roomTypes, } from "./schema-inventory.js";
+import { ACCOMMODATION_CONTENT_MARKET_ANY, accommodationSourcedContentTable, } from "./schema-sourced-content.js";
+import { synthesizeAccommodationContent, } from "./service-content-synthesizer.js";
+/**
+ * Accommodation cache TTL is 4h by default — significantly shorter than
+ * products / cruises because room availability and rate plans churn
+ * faster on bedbanks. Per §3.4: products 24h, hotels 4h.
+ */
+const ACCOMMODATION_DEFAULT_TTL_MS = 4 * 60 * 60 * 1000;
+export async function getAccommodationContent(db, entityId, scope, options) {
+    const sourcedEntry = await readSourcedEntry(db, "accommodations", entityId);
+    if (!sourcedEntry) {
+        const owned = await buildOwnedAccommodationContent(db, entityId, {
+            preferredLocales: scope.preferredLocales,
+        });
+        if (!owned)
+            return null;
+        const overlays = await fetchOverlaysForEntity(db, "accommodations", entityId);
+        const merged = mergeOverlaysIntoAccommodationContent(owned.content, overlays.map((o) => ({ field_path: o.field_path, value: o.value })), {
+            onOverlayError: options.onOverlayError
+                ? (e) => options.onOverlayError({
+                    field_path: e.overlay.field_path,
+                    reason: e.reason,
+                })
+                : undefined,
+        });
+        return {
+            content: merged,
+            resolution: {
+                candidate: { locale: owned.servedLocale, payload: merged },
+                served_locale: owned.servedLocale,
+                match_kind: owned.matchKind,
+            },
+            source: "owned",
+            served_stale: false,
+            synthesized: false,
+            machine_translated: false,
+        };
+    }
+    const provenance = {
+        kind: "sourced",
+        provenance: {
+            source_kind: sourcedEntry.source_kind,
+            source_provider: sourcedEntry.source_provider ?? undefined,
+            source_connection_id: sourcedEntry.source_connection_id ?? undefined,
+            source_ref: sourcedEntry.source_ref ?? undefined,
+            source_freshness: sourcedEntry.source_freshness,
+            last_sourced_at: sourcedEntry.last_sourced_at ?? undefined,
+        },
+        entry_id: sourcedEntry.id,
+        status: sourcedEntry.status,
+        projection: sourcedEntry.projection,
+        projection_etag: sourcedEntry.projection_etag,
+        projection_seen_at: sourcedEntry.projection_seen_at,
+        first_seen_at: sourcedEntry.first_seen_at,
+        last_seen_at: sourcedEntry.last_seen_at,
+    };
+    const adapter = sourcedEntry.source_connection_id
+        ? (options.registry.resolveByConnection(sourcedEntry.source_connection_id) ??
+            options.registry.byKind(sourcedEntry.source_kind)[0]?.adapter)
+        : options.registry.byKind(sourcedEntry.source_kind)[0]?.adapter;
+    const adapterCtx = options.buildAdapterContext?.(adapter) ?? {
+        connection_id: sourcedEntry.source_connection_id ?? sourcedEntry.source_kind,
+    };
+    const market = scope.market ?? ACCOMMODATION_CONTENT_MARKET_ANY;
+    const acceptMT = scope.acceptMachineTranslated ?? true;
+    const cachedRows = await fetchCacheCandidates(db, entityId, market);
+    const eligibleRows = acceptMT ? cachedRows : cachedRows.filter((r) => !r.machine_translated);
+    const best = pickBestCachedLocale(eligibleRows.map((row) => ({ ...row, locale: row.locale })), scope.preferredLocales);
+    if (best && !isStale(best.candidate)) {
+        return finalizeFromCache(db, entityId, best, false, options);
+    }
+    if (best && isStale(best.candidate)) {
+        if (adapter?.getContent) {
+            void scheduleRefresh(db, adapter, adapterCtx, {
+                entity_module: "accommodations",
+                entity_id: entityId,
+                locale: scope.preferredLocales[0] ?? best.candidate.locale,
+                market,
+                currency: scope.currency,
+            });
+        }
+        return finalizeFromCache(db, entityId, best, true, options);
+    }
+    if (!adapter?.getContent) {
+        const overlays = await fetchOverlaysForEntity(db, "accommodations", entityId);
+        const synthesized = synthesizeAccommodationContent({ locale: scope.preferredLocales[0] ?? "en-GB" }, {
+            provenance,
+            overlays: overlays.map((o) => ({ field_path: o.field_path, value: o.value })),
+        });
+        return wrapSynthesized(synthesized, scope, false);
+    }
+    const fresh = await fetchFreshContent(db, adapter, adapterCtx, {
+        entity_module: "accommodations",
+        entity_id: entityId,
+        locale: scope.preferredLocales[0] ?? "en-GB",
+        market,
+        currency: scope.currency,
+    });
+    if (!fresh) {
+        const overlays = await fetchOverlaysForEntity(db, "accommodations", entityId);
+        const synthesized = synthesizeAccommodationContent({ locale: scope.preferredLocales[0] ?? "en-GB" }, {
+            provenance,
+            overlays: overlays.map((o) => ({ field_path: o.field_path, value: o.value })),
+        });
+        return wrapSynthesized(synthesized, scope, false);
+    }
+    return finalizeFresh(db, entityId, fresh, scope, options);
+}
+export async function buildOwnedAccommodationContent(db, entityId, options) {
+    // biome-ignore lint/suspicious/noExplicitAny: AnyDrizzleDb widens drizzle's row inference.
+    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.
+    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",
+    };
+}
+async function fetchCacheCandidates(db, entityId, market) {
+    return db
+        .select()
+        .from(accommodationSourcedContentTable)
+        .where(and(eq(accommodationSourcedContentTable.entity_id, entityId), eq(accommodationSourcedContentTable.market, market), eq(accommodationSourcedContentTable.content_schema_version, ACCOMMODATION_CONTENT_SCHEMA_VERSION)));
+}
+async function fetchFreshContent(db, adapter, ctx, request) {
+    const result = await withContentRefreshLock(db, {
+        entityModule: request.entity_module,
+        entityId: request.entity_id,
+        locale: request.locale,
+        market: request.market,
+    }, async () => {
+        const got = await adapter.getContent(ctx, request);
+        const validation = validateAccommodationContent(got.content);
+        if (!validation.valid) {
+            throw new Error(`accommodation getContent for ${request.entity_id} failed validation: ${validation.reason}`);
+        }
+        await writeCacheRow(db, request, got);
+        return got;
+    });
+    return result ?? null;
+}
+function scheduleRefresh(db, adapter, ctx, request) {
+    void withContentRefreshLock(db, {
+        entityModule: request.entity_module,
+        entityId: request.entity_id,
+        locale: request.locale,
+        market: request.market,
+    }, async () => {
+        const got = await adapter.getContent(ctx, request);
+        const validation = validateAccommodationContent(got.content);
+        if (!validation.valid)
+            return;
+        await writeCacheRow(db, request, got);
+    }).catch(() => {
+        // intentional swallow — see §3.4 SWR refresh contract
+    });
+}
+async function writeCacheRow(db, request, result) {
+    const market = request.market ?? ACCOMMODATION_CONTENT_MARKET_ANY;
+    const now = new Date();
+    // Coerce JSON-string dates to Date — see products writeCacheRow.
+    const sourceUpdatedAt = toDateOrNull(result.source_updated_at);
+    const freshUntil = toDateOrNull(result.fresh_until) ?? new Date(now.getTime() + ACCOMMODATION_DEFAULT_TTL_MS);
+    await db
+        .insert(accommodationSourcedContentTable)
+        .values({
+        entity_id: request.entity_id,
+        locale: request.locale,
+        market,
+        payload: result.content,
+        content_schema_version: result.content_schema_version,
+        returned_locale: result.returned_locale,
+        machine_translated: result.machine_translated ?? false,
+        source_updated_at: sourceUpdatedAt,
+        fetched_at: now,
+        fresh_until: freshUntil,
+        etag: result.etag ?? null,
+        fetch_status: "ok",
+        fetch_error: null,
+    })
+        .onConflictDoUpdate({
+        target: [
+            accommodationSourcedContentTable.entity_id,
+            accommodationSourcedContentTable.locale,
+            accommodationSourcedContentTable.market,
+        ],
+        set: {
+            payload: result.content,
+            content_schema_version: result.content_schema_version,
+            returned_locale: result.returned_locale,
+            machine_translated: result.machine_translated ?? false,
+            source_updated_at: sourceUpdatedAt,
+            fetched_at: now,
+            fresh_until: freshUntil,
+            etag: result.etag ?? null,
+            fetch_status: "ok",
+            fetch_error: null,
+        },
+    });
+}
+async function finalizeFromCache(db, entityId, best, servedStale, options) {
+    const validation = validateAccommodationContent(best.candidate.payload);
+    if (!validation.valid) {
+        throw new Error(`accommodation cache row for ${entityId} (${best.candidate.locale}) failed validation: ${validation.reason}`);
+    }
+    const overlays = await fetchOverlaysForEntity(db, "accommodations", entityId);
+    const merged = mergeOverlaysIntoAccommodationContent(validation.content, overlays.map((o) => ({ field_path: o.field_path, value: o.value })), {
+        onOverlayError: options.onOverlayError
+            ? (e) => options.onOverlayError({
+                field_path: e.overlay.field_path,
+                reason: e.reason,
+            })
+            : undefined,
+    });
+    return {
+        content: merged,
+        resolution: {
+            candidate: { locale: best.candidate.locale, payload: merged },
+            served_locale: best.candidate.returned_locale,
+            match_kind: best.match_kind,
+        },
+        source: "sourced-cache",
+        served_stale: servedStale,
+        synthesized: false,
+        machine_translated: best.candidate.machine_translated,
+    };
+}
+async function finalizeFresh(db, entityId, fresh, scope, options) {
+    const cachedContent = accommodationContentSchema.parse(fresh.content);
+    const overlays = await fetchOverlaysForEntity(db, "accommodations", entityId);
+    const merged = mergeOverlaysIntoAccommodationContent(cachedContent, overlays.map((o) => ({ field_path: o.field_path, value: o.value })), {
+        onOverlayError: options.onOverlayError
+            ? (e) => options.onOverlayError({
+                field_path: e.overlay.field_path,
+                reason: e.reason,
+            })
+            : undefined,
+    });
+    return {
+        content: merged,
+        resolution: {
+            candidate: { locale: scope.preferredLocales[0] ?? fresh.returned_locale, payload: merged },
+            served_locale: fresh.returned_locale,
+            match_kind: scope.preferredLocales[0] === fresh.returned_locale ? "exact" : "language_match",
+        },
+        source: "sourced-fresh",
+        served_stale: false,
+        synthesized: false,
+        machine_translated: fresh.machine_translated ?? false,
+    };
+}
+function wrapSynthesized(synthesized, scope, servedStale) {
+    return {
+        content: synthesized.content,
+        resolution: {
+            candidate: { locale: synthesized.served_locale, payload: synthesized.content },
+            served_locale: synthesized.served_locale,
+            match_kind: scope.preferredLocales[0] === synthesized.served_locale ? "exact" : "any",
+        },
+        source: "synthesized",
+        served_stale: servedStale,
+        synthesized: true,
+        machine_translated: false,
+    };
+}
+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)
+        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;
+}
+/** Drift event consumer for the accommodation content cache. Per §3.4.1. */
+export const invalidateAccommodationContentOnDrift = createInvalidateOnDrift(accommodationSourcedContentTable, { entityModule: "accommodations" });
+function toDateOrNull(value) {
+    if (!value)
+        return null;
+    if (value instanceof Date)
+        return value;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@voyantjs/accommodations",
+  "version": "0.55.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./schema": "./src/schema.ts",
+    "./content-shape": "./src/content-shape.ts",
+    "./service-content": "./src/service-content.ts",
+    "./service-content-synthesizer": "./src/service-content-synthesizer.ts",
+    "./catalog-policy": "./src/catalog-policy.ts",
+    "./service-catalog-plane": "./src/service-catalog-plane.ts",
+    "./draft-shape": "./src/draft-shape.ts",
+    "./booking-engine": "./src/booking-engine/index.ts",
+    "./routes-content": "./src/routes-content.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "prepack": "pnpm run build"
+  },
+  "dependencies": {
+    "@voyantjs/bookings": "workspace:*",
+    "@voyantjs/catalog": "workspace:*",
+    "@voyantjs/db": "workspace:*",
+    "@voyantjs/facilities": "workspace:*",
+    "drizzle-orm": "^0.45.2",
+    "hono": "^4.12.10",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@voyantjs/voyant-typescript-config": "workspace:*",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "./schema": {
+        "types": "./dist/schema.d.ts",
+        "import": "./dist/schema.js",
+        "default": "./dist/schema.js"
+      },
+      "./content-shape": {
+        "types": "./dist/content-shape.d.ts",
+        "import": "./dist/content-shape.js",
+        "default": "./dist/content-shape.js"
+      },
+      "./service-content": {
+        "types": "./dist/service-content.d.ts",
+        "import": "./dist/service-content.js",
+        "default": "./dist/service-content.js"
+      },
+      "./service-content-synthesizer": {
+        "types": "./dist/service-content-synthesizer.d.ts",
+        "import": "./dist/service-content-synthesizer.js",
+        "default": "./dist/service-content-synthesizer.js"
+      },
+      "./catalog-policy": {
+        "types": "./dist/catalog-policy.d.ts",
+        "import": "./dist/catalog-policy.js",
+        "default": "./dist/catalog-policy.js"
+      },
+      "./service-catalog-plane": {
+        "types": "./dist/service-catalog-plane.d.ts",
+        "import": "./dist/service-catalog-plane.js",
+        "default": "./dist/service-catalog-plane.js"
+      },
+      "./draft-shape": {
+        "types": "./dist/draft-shape.d.ts",
+        "import": "./dist/draft-shape.js",
+        "default": "./dist/draft-shape.js"
+      },
+      "./booking-engine": {
+        "types": "./dist/booking-engine/index.d.ts",
+        "import": "./dist/booking-engine/index.js",
+        "default": "./dist/booking-engine/index.js"
+      },
+      "./routes-content": {
+        "types": "./dist/routes-content.d.ts",
+        "import": "./dist/routes-content.js",
+        "default": "./dist/routes-content.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/accommodations"
+  },
+  "voyant": {
+    "schema": "./schema",
+    "requiresSchemas": [
+      "@voyantjs/db",
+      "@voyantjs/facilities",
+      "@voyantjs/bookings"
+    ]
+  }
+}