@voyant-travel/cruises 0.118.2

package/dist/routes-public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAYjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;KACvB,CAAA;CACF,CAAA;AAkFD;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA6K3B,CAAA;AAEJ,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA"}

package/dist/routes-public.js

@@ -0,0 +1,252 @@
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { z } from "zod";
+import { resolveCruiseAdapter } from "./adapters/registry.js";
+import { encodeSourceRef, parseUnifiedKey, sourceRefFromExternalKeyRef } from "./lib/key.js";
+import { cruisesService } from "./service.js";
+import { composeQuote, pricingService } from "./service-pricing.js";
+import { cruisesSearchService } from "./service-search.js";
+import { searchIndexQuerySchema } from "./validation-search.js";
+const TYPEID_RE = /^[a-z]+_[0-9a-zA-Z]+$/;
+function isTypeId(s) {
+    return TYPEID_RE.test(s);
+}
+const quotePayloadSchema = z.object({
+    cabinCategoryId: z.string(),
+    cabinCategoryRef: z.record(z.string(), z.unknown()).optional().nullable(),
+    occupancy: z.number().int().min(1).max(8),
+    guestCount: z.number().int().min(1).max(8).optional(),
+    passengerComposition: passengerCompositionSchema().optional().nullable(),
+    fareCode: z.string().optional().nullable(),
+    fareVariant: z.enum(["cruise_only", "air_inclusive"]).optional().nullable(),
+    bookingTerms: z.record(z.string(), z.unknown()).optional().nullable(),
+});
+function passengerCompositionSchema() {
+    return z
+        .object({
+        adults: z.number().int().min(0),
+        children: z.number().int().min(0).optional(),
+        childAges: z.array(z.number().int().min(0).max(17)).optional(),
+        infants: z.number().int().min(0).optional(),
+        seniors: z.number().int().min(0).optional(),
+    })
+        .catchall(z.unknown())
+        .refine((value) => value.adults + (value.children ?? 0) + (value.infants ?? 0) + (value.seniors ?? 0) > 0, "passengerComposition must include at least one passenger");
+}
+function passengerCountFromComposition(composition) {
+    if (!composition)
+        return null;
+    return (composition.adults +
+        (composition.children ?? 0) +
+        (composition.infants ?? 0) +
+        (composition.seniors ?? 0));
+}
+function resolveExternalKey(key) {
+    const parsed = parseUnifiedKey(key);
+    if (parsed.kind !== "external")
+        return null;
+    return { provider: parsed.provider, sourceRef: sourceRefFromExternalKeyRef(parsed.ref) };
+}
+function sourceRefFromPayload(maybeRef, externalId) {
+    if (maybeRef && typeof maybeRef.externalId === "string")
+        return maybeRef;
+    return { externalId };
+}
+function sourceRefMatches(candidate, requested) {
+    if (encodeSourceRef(candidate) === encodeSourceRef(requested))
+        return true;
+    const candidateIsLegacy = Object.keys(candidate).length === 1;
+    const requestedIsLegacy = Object.keys(requested).length === 1;
+    return (candidateIsLegacy || requestedIsLegacy) && candidate.externalId === requested.externalId;
+}
+function passengerCompositionMatches(candidate, requested) {
+    if (!requested || !candidate)
+        return true;
+    return (encodeSourceRef({
+        externalId: "composition",
+        ...candidate,
+    }) === encodeSourceRef({ externalId: "composition", ...requested }));
+}
+/**
+ * Public/storefront routes. Reads exclusively from `cruise_search_index` for
+ * list and slug lookups; detail endpoints (sailing, ship, quote) resolve
+ * through the appropriate source — local DB for source='local' rows, the
+ * registered adapter for source='external'.
+ *
+ * Operators that don't run a Voyant-powered storefront leave the search index
+ * empty; the list endpoint returns no rows but detail endpoints still work
+ * for direct sailing/ship key lookups.
+ */
+export const cruisePublicRoutes = new Hono()
+    .get("/", async (c) => {
+    const query = parseQuery(c, searchIndexQuerySchema);
+    const result = await cruisesSearchService.query(c.get("db"), query);
+    return c.json(result);
+})
+    .get("/:slug", async (c) => {
+    const slug = c.req.param("slug");
+    const indexEntry = await cruisesSearchService.getBySlug(c.get("db"), slug);
+    if (!indexEntry)
+        return c.json({ error: "not_found" }, 404);
+    if (indexEntry.source === "local" && indexEntry.localCruiseId) {
+        const detail = await cruisesService.getCruiseById(c.get("db"), indexEntry.localCruiseId, {
+            withSailings: true,
+            withDays: true,
+        });
+        if (!detail)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({
+            data: {
+                source: "local",
+                sourceProvider: null,
+                sourceRef: null,
+                summary: indexEntry,
+                cruise: detail,
+            },
+        });
+    }
+    if (indexEntry.source === "external" && indexEntry.sourceProvider && indexEntry.sourceRef) {
+        const externalId = indexEntry.sourceRef.externalId;
+        if (typeof externalId !== "string" || externalId.length === 0) {
+            return c.json({ error: "invalid_index_entry", detail: "sourceRef.externalId missing" }, 500);
+        }
+        const adapter = resolveCruiseAdapter(indexEntry.sourceProvider);
+        if (!adapter) {
+            return c.json({
+                error: "adapter_not_registered",
+                detail: `Search-index entry references provider '${indexEntry.sourceProvider}' but no adapter is registered.`,
+            }, 501);
+        }
+        const adapterRef = { ...indexEntry.sourceRef, externalId };
+        const cruise = await adapter.fetchCruise(adapterRef);
+        if (!cruise)
+            return c.json({ error: "not_found" }, 404);
+        const sailings = await adapter.listSailingsForCruise(adapterRef);
+        return c.json({
+            data: {
+                source: "external",
+                sourceProvider: adapter.name,
+                sourceRef: adapterRef,
+                summary: indexEntry,
+                cruise,
+                sailings,
+            },
+        });
+    }
+    return c.json({ error: "invalid_index_entry" }, 500);
+})
+    .get("/sailings/:key", async (c) => {
+    const key = c.req.param("key");
+    if (isTypeId(key)) {
+        const sailing = await cruisesService.getSailingById(c.get("db"), key, {
+            withPricing: true,
+            withItinerary: true,
+        });
+        if (!sailing)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({ data: { source: "local", sailing } });
+    }
+    const parsed = resolveExternalKey(key);
+    if (!parsed)
+        return c.json({ error: "invalid_key" }, 400);
+    const adapter = resolveCruiseAdapter(parsed.provider);
+    if (!adapter)
+        return c.json({ error: "adapter_not_registered" }, 501);
+    const sailing = await adapter.fetchSailing(parsed.sourceRef);
+    if (!sailing)
+        return c.json({ error: "not_found" }, 404);
+    const [pricing, itinerary] = await Promise.all([
+        adapter.fetchSailingPricing(parsed.sourceRef),
+        adapter.fetchSailingItinerary(parsed.sourceRef),
+    ]);
+    return c.json({
+        data: { source: "external", sourceProvider: adapter.name, sailing, pricing, itinerary },
+    });
+})
+    .post("/sailings/:key/quote", async (c) => {
+    const key = c.req.param("key");
+    const payload = await parseJsonBody(c, quotePayloadSchema);
+    const guestCount = payload.guestCount ?? passengerCountFromComposition(payload.passengerComposition);
+    if (!guestCount) {
+        return c.json({
+            error: "guest_count_required",
+            detail: "Provide guestCount or passengerComposition for cruise quote requests.",
+        }, 400);
+    }
+    if (isTypeId(key)) {
+        const quote = await pricingService.assembleQuote(c.get("db"), {
+            sailingId: key,
+            cabinCategoryId: payload.cabinCategoryId,
+            occupancy: payload.occupancy,
+            guestCount,
+            fareCode: payload.fareCode ?? null,
+            fareVariant: payload.fareVariant ?? null,
+        });
+        return c.json({ data: quote });
+    }
+    const parsed = resolveExternalKey(key);
+    if (!parsed)
+        return c.json({ error: "invalid_key" }, 400);
+    const adapter = resolveCruiseAdapter(parsed.provider);
+    if (!adapter)
+        return c.json({ error: "adapter_not_registered" }, 501);
+    const prices = await adapter.fetchSailingPricing(parsed.sourceRef);
+    const cabinCategoryRef = sourceRefFromPayload(payload.cabinCategoryRef, payload.cabinCategoryId);
+    const matching = prices.find((p) => sourceRefMatches(p.cabinCategoryRef, cabinCategoryRef) &&
+        p.occupancy === payload.occupancy &&
+        passengerCompositionMatches(p.passengerComposition, payload.passengerComposition) &&
+        (!payload.fareCode || p.fareCode === payload.fareCode) &&
+        (!payload.fareVariant || p.fareVariant === payload.fareVariant));
+    if (!matching)
+        return c.json({ error: "no_matching_price" }, 404);
+    const quote = composeQuote({
+        price: {
+            pricePerPerson: matching.pricePerPerson,
+            originalPricePerPerson: matching.originalPricePerPerson ?? null,
+            secondGuestPricePerPerson: matching.secondGuestPricePerPerson ?? null,
+            singlePricePerPerson: matching.singlePricePerPerson ?? null,
+            singleSupplementPercent: matching.singleSupplementPercent ?? null,
+            currency: matching.currency,
+            fareCode: matching.fareCode ?? null,
+            fareCodeName: matching.fareCodeName ?? null,
+            fareVariant: matching.fareVariant ?? "cruise_only",
+            earlyBookingDeadline: matching.earlyBookingDeadline ?? null,
+            earlyBookingBonusDescription: matching.earlyBookingBonusDescription ?? null,
+        },
+        components: (matching.components ?? []).map((c) => ({
+            kind: c.kind,
+            label: c.label ?? null,
+            amount: c.amount,
+            currency: c.currency,
+            direction: c.direction,
+            perPerson: c.perPerson,
+        })),
+        occupancy: payload.occupancy,
+        guestCount,
+        bookingTerms: payload.bookingTerms ?? matching.bookingTerms ?? null,
+    });
+    return c.json({ data: quote });
+})
+    .get("/ships/:key", async (c) => {
+    const key = c.req.param("key");
+    if (isTypeId(key)) {
+        const ship = await cruisesService.getShipById(c.get("db"), key);
+        if (!ship)
+            return c.json({ error: "not_found" }, 404);
+        const [decks, categories] = await Promise.all([
+            cruisesService.listShipDecks(c.get("db"), key),
+            cruisesService.listShipCabinCategories(c.get("db"), key),
+        ]);
+        return c.json({ data: { ...ship, decks, categories } });
+    }
+    const parsed = resolveExternalKey(key);
+    if (!parsed)
+        return c.json({ error: "invalid_key" }, 400);
+    const adapter = resolveCruiseAdapter(parsed.provider);
+    if (!adapter)
+        return c.json({ error: "adapter_not_registered" }, 501);
+    const ship = await adapter.fetchShip(parsed.sourceRef);
+    if (!ship)
+        return c.json({ error: "not_found" }, 404);
+    return c.json({ data: ship });
+});

package/dist/routes-sailings-prices.d.ts

@@ -0,0 +1,4 @@
+import type { Hono } from "hono";
+import type { CruiseRoutesEnv as Env } from "./routes-env.js";
+export declare function registerCruiseSailingAndPriceRoutes(app: Hono<Env>): void;
+//# sourceMappingURL=routes-sailings-prices.d.ts.map

package/dist/routes-sailings-prices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-sailings-prices.d.ts","sourceRoot":"","sources":["../src/routes-sailings-prices.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAahC,OAAO,KAAK,EAAE,eAAe,IAAI,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAkB7D,wBAAgB,mCAAmC,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,QAgSjE"}

package/dist/routes-sailings-prices.js

@@ -0,0 +1,278 @@
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { z } from "zod";
+import { parseUnifiedKey } from "./lib/key.js";
+import { createBookingPayloadSchema, createPartyBookingPayloadSchema, passengerCompositionMatches, passengerCountFromComposition, quotePayloadSchema, sourceRefFromPayload, sourceRefMatches, } from "./routes-booking-payloads.js";
+import { adapterNotRegistered, invalidKey, resolveExternal } from "./routes-keying.js";
+import { cruisesService } from "./service.js";
+import { cruisesBookingService } from "./service-bookings.js";
+import { pricingService } from "./service-pricing.js";
+import { insertSailingSchema, sailingListQuerySchema, updateSailingSchema, } from "./validation-core.js";
+import { replaceSailingDaysSchema } from "./validation-itinerary.js";
+import { insertPriceComponentSchema, insertPriceSchema, priceListQuerySchema, updatePriceSchema, } from "./validation-pricing.js";
+export function registerCruiseSailingAndPriceRoutes(app) {
+    app
+        // --- sailings ---
+        .get("/sailings", async (c) => {
+        const query = parseQuery(c, sailingListQuerySchema);
+        const result = await cruisesService.listSailings(c.get("db"), query);
+        return c.json(result);
+    })
+        .get("/sailings/:key", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        if (parsed.kind === "external") {
+            const ext = resolveExternal(parsed);
+            if (!ext)
+                return c.json(adapterNotRegistered(parsed.provider), 501);
+            const sailing = await ext.adapter.fetchSailing(ext.sourceRef);
+            if (!sailing)
+                return c.json({ error: "not_found" }, 404);
+            const includeRaw = c.req.query("include") ?? "";
+            const includes = new Set(includeRaw
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean));
+            const enriched = {
+                source: "external",
+                sourceProvider: ext.adapter.name,
+                sourceRef: sailing.sourceRef,
+                sailing,
+            };
+            if (includes.has("pricing")) {
+                enriched.pricing = await ext.adapter.fetchSailingPricing(ext.sourceRef);
+            }
+            if (includes.has("itinerary")) {
+                enriched.itinerary = await ext.adapter.fetchSailingItinerary(ext.sourceRef);
+            }
+            return c.json({ data: enriched });
+        }
+        const includeRaw = c.req.query("include") ?? "";
+        const includes = new Set(includeRaw
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean));
+        const row = await cruisesService.getSailingById(c.get("db"), parsed.id, {
+            withPricing: includes.has("pricing"),
+            withItinerary: includes.has("itinerary"),
+        });
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({ data: row });
+    })
+        .post("/sailings", async (c) => {
+        const data = await parseJsonBody(c, insertSailingSchema);
+        const row = await cruisesService.upsertSailing(c.get("db"), data);
+        return c.json({ data: row }, 201);
+    })
+        .put("/sailings/:key", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external")
+            return c.json({ error: "external_cruise_read_only" }, 409);
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const data = await parseJsonBody(c, updateSailingSchema);
+        const row = await cruisesService.updateSailing(c.get("db"), parsed.id, data);
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({ data: row });
+    })
+        .get("/sailings/:key/itinerary", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        if (parsed.kind === "external") {
+            const ext = resolveExternal(parsed);
+            if (!ext)
+                return c.json(adapterNotRegistered(parsed.provider), 501);
+            const days = await ext.adapter.fetchSailingItinerary(ext.sourceRef);
+            return c.json({ data: days });
+        }
+        const days = await cruisesService.getEffectiveItinerary(c.get("db"), parsed.id);
+        return c.json({ data: days });
+    })
+        .put("/sailings/:key/days/bulk", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external")
+            return c.json({ error: "external_cruise_read_only" }, 409);
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const payload = await parseJsonBody(c, replaceSailingDaysSchema.omit({ sailingId: true }));
+        const days = await cruisesService.replaceSailingDays(c.get("db"), {
+            sailingId: parsed.id,
+            days: payload.days,
+        });
+        return c.json({ data: days });
+    })
+        .get("/sailings/:key/pricing", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        if (parsed.kind === "external") {
+            const ext = resolveExternal(parsed);
+            if (!ext)
+                return c.json(adapterNotRegistered(parsed.provider), 501);
+            const prices = await ext.adapter.fetchSailingPricing(ext.sourceRef);
+            return c.json({ data: prices });
+        }
+        const result = await cruisesService.listPrices(c.get("db"), {
+            sailingId: parsed.id,
+            limit: 100,
+            offset: 0,
+        });
+        return c.json(result);
+    })
+        .put("/sailings/:key/pricing/bulk", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "external")
+            return c.json({ error: "external_cruise_read_only" }, 409);
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const payload = await parseJsonBody(c, z.object({
+            prices: z.array(insertPriceSchema.extend({
+                components: z.array(insertPriceComponentSchema.omit({ priceId: true })).optional(),
+            })),
+        }));
+        const data = await cruisesService.replaceSailingPricing(c.get("db"), parsed.id, payload);
+        return c.json({ data });
+    })
+        .post("/sailings/:key/quote", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        const payload = await parseJsonBody(c, quotePayloadSchema);
+        const guestCount = payload.guestCount ?? passengerCountFromComposition(payload.passengerComposition);
+        if (!guestCount) {
+            return c.json({
+                error: "guest_count_required",
+                detail: "Provide guestCount or passengerComposition for cruise quote requests.",
+            }, 400);
+        }
+        if (parsed.kind === "external") {
+            const ext = resolveExternal(parsed);
+            if (!ext)
+                return c.json(adapterNotRegistered(parsed.provider), 501);
+            // Fetch upstream pricing then compose locally — the cabinCategoryId in
+            // the payload is interpreted as the upstream cabin category externalId.
+            const prices = await ext.adapter.fetchSailingPricing(ext.sourceRef);
+            const cabinCategoryRef = sourceRefFromPayload(payload.cabinCategoryRef, payload.cabinCategoryId);
+            const matching = prices.find((p) => sourceRefMatches(p.cabinCategoryRef, cabinCategoryRef) &&
+                p.occupancy === payload.occupancy &&
+                passengerCompositionMatches(p.passengerComposition, payload.passengerComposition) &&
+                (!payload.fareCode || p.fareCode === payload.fareCode) &&
+                (!payload.fareVariant || p.fareVariant === payload.fareVariant));
+            if (!matching)
+                return c.json({ error: "no_matching_price" }, 404);
+            const { composeQuote } = await import("./service-pricing.js");
+            const quote = composeQuote({
+                price: {
+                    pricePerPerson: matching.pricePerPerson,
+                    originalPricePerPerson: matching.originalPricePerPerson ?? null,
+                    secondGuestPricePerPerson: matching.secondGuestPricePerPerson ?? null,
+                    singlePricePerPerson: matching.singlePricePerPerson ?? null,
+                    singleSupplementPercent: matching.singleSupplementPercent ?? null,
+                    currency: matching.currency,
+                    fareCode: matching.fareCode ?? null,
+                    fareCodeName: matching.fareCodeName ?? null,
+                    fareVariant: matching.fareVariant ?? "cruise_only",
+                    earlyBookingDeadline: matching.earlyBookingDeadline ?? null,
+                    earlyBookingBonusDescription: matching.earlyBookingBonusDescription ?? null,
+                },
+                components: (matching.components ?? []).map((c) => ({
+                    kind: c.kind,
+                    label: c.label ?? null,
+                    amount: c.amount,
+                    currency: c.currency,
+                    direction: c.direction,
+                    perPerson: c.perPerson,
+                })),
+                occupancy: payload.occupancy,
+                guestCount,
+                bookingTerms: matching.bookingTerms ?? null,
+            });
+            return c.json({ data: quote });
+        }
+        const quote = await pricingService.assembleQuote(c.get("db"), {
+            sailingId: parsed.id,
+            cabinCategoryId: payload.cabinCategoryId,
+            occupancy: payload.occupancy,
+            guestCount,
+            fareCode: payload.fareCode ?? null,
+            fareVariant: payload.fareVariant ?? null,
+        });
+        return c.json({ data: quote });
+    })
+        // --- bookings (single + party) ---
+        .post("/sailings/:key/bookings", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        if (parsed.kind === "external") {
+            const ext = resolveExternal(parsed);
+            if (!ext)
+                return c.json(adapterNotRegistered(parsed.provider), 501);
+            const payload = await parseJsonBody(c, createBookingPayloadSchema);
+            const result = await cruisesBookingService.createExternalCruiseBooking(c.get("db"), {
+                adapter: ext.adapter,
+                sailingRef: ext.sourceRef,
+                cabinCategoryRef: sourceRefFromPayload(payload.cabinCategoryRef, payload.cabinCategoryId),
+                cabinId: payload.cabinId ?? null,
+                occupancy: payload.occupancy,
+                passengerComposition: payload.passengerComposition ?? null,
+                fareCode: payload.fareCode ?? null,
+                fareVariant: payload.fareVariant ?? null,
+                mode: payload.mode,
+                personId: payload.personId ?? null,
+                organizationId: payload.organizationId ?? null,
+                contact: payload.contact,
+                passengers: payload.passengers,
+                notes: payload.notes ?? null,
+            }, c.get("userId"));
+            return c.json({ data: result }, 201);
+        }
+        const payload = await parseJsonBody(c, createBookingPayloadSchema);
+        if (payload.sailingId !== parsed.id) {
+            return c.json({ error: "sailing_id_mismatch", detail: "URL key and payload sailingId must match" }, 400);
+        }
+        const result = await cruisesBookingService.createCruiseBooking(c.get("db"), payload, c.get("userId"));
+        return c.json({ data: result }, 201);
+    })
+        .post("/sailings/:key/party-bookings", async (c) => {
+        const parsed = parseUnifiedKey(c.req.param("key"));
+        if (parsed.kind === "invalid")
+            return c.json(invalidKey(parsed.raw), 400);
+        if (parsed.kind === "external") {
+            // External party bookings deferred — most cruise lines don't expose a
+            // multi-cabin atomic upstream commit; we'd have to implement the group
+            // semantics by serial bookings + rollback. Out of v1 scope.
+            return c.json({
+                error: "external_party_booking_not_supported",
+                detail: "Multi-cabin party bookings against external adapters are not yet supported. Submit each cabin individually via POST /sailings/:key/bookings.",
+            }, 501);
+        }
+        const payload = await parseJsonBody(c, createPartyBookingPayloadSchema);
+        if (payload.sailingId !== parsed.id) {
+            return c.json({ error: "sailing_id_mismatch", detail: "URL key and payload sailingId must match" }, 400);
+        }
+        const result = await cruisesBookingService.createCruisePartyBooking(c.get("db"), payload, c.get("userId"));
+        return c.json({ data: result }, 201);
+    })
+        // --- prices (read endpoints; mutations go through bulk replace on the sailing) ---
+        .get("/prices", async (c) => {
+        const query = parseQuery(c, priceListQuerySchema);
+        const result = await cruisesService.listPrices(c.get("db"), query);
+        return c.json(result);
+    })
+        .post("/prices", async (c) => {
+        const data = await parseJsonBody(c, insertPriceSchema);
+        const row = await cruisesService.createPrice(c.get("db"), data);
+        return c.json({ data: row }, 201);
+    })
+        .put("/prices/:priceId", async (c) => {
+        const data = await parseJsonBody(c, updatePriceSchema);
+        const row = await cruisesService.updatePrice(c.get("db"), c.req.param("priceId"), data);
+        if (!row)
+            return c.json({ error: "not_found" }, 404);
+        return c.json({ data: row });
+    });
+}

package/dist/routes-search-index.d.ts

@@ -0,0 +1,4 @@
+import type { Hono } from "hono";
+import type { CruiseRoutesEnv as Env } from "./routes-env.js";
+export declare function registerCruiseSearchIndexRoutes(app: Hono<Env>): void;
+//# sourceMappingURL=routes-search-index.d.ts.map

package/dist/routes-search-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-search-index.d.ts","sourceRoot":"","sources":["../src/routes-search-index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAGhC,OAAO,KAAK,EAAE,eAAe,IAAI,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAI7D,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,QAsB7D"}

package/dist/routes-search-index.js

@@ -0,0 +1,25 @@
+import { parseJsonBody } from "@voyant-travel/hono";
+import { z } from "zod";
+import { cruisesSearchService } from "./service-search.js";
+import { insertSearchIndexSchema } from "./validation-search.js";
+export function registerCruiseSearchIndexRoutes(app) {
+    app
+        // --- search-index management ---
+        .put("/search-index/bulk", async (c) => {
+        const payload = await parseJsonBody(c, z.object({
+            entries: z.array(insertSearchIndexSchema),
+        }));
+        const result = await cruisesSearchService.bulkUpsert(c.get("db"), payload.entries);
+        return c.json({ data: result });
+    })
+        .delete("/search-index/:crsiId", async (c) => {
+        const ok = await cruisesSearchService.removeEntry(c.get("db"), c.req.param("crsiId"));
+        if (!ok)
+            return c.json({ error: "not_found" }, 404);
+        return c.body(null, 204);
+    })
+        .post("/search-index/rebuild", async (c) => {
+        const result = await cruisesSearchService.rebuildAll(c.get("db"));
+        return c.json({ data: result });
+    });
+}

package/dist/routes-ships.d.ts

@@ -0,0 +1,4 @@
+import type { Hono } from "hono";
+import type { CruiseRoutesEnv as Env } from "./routes-env.js";
+export declare function registerCruiseShipRoutes(app: Hono<Env>): void;
+//# sourceMappingURL=routes-ships.d.ts.map

package/dist/routes-ships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-ships.d.ts","sourceRoot":"","sources":["../src/routes-ships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAIhC,OAAO,KAAK,EAAE,eAAe,IAAI,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAe7D,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,QAuItD"}