@voyant-travel/flights 0.119.2

package/dist/contract/schemas.test.js

@@ -0,0 +1,360 @@
+// agent-quality: file-size exception -- owner: flights; existing coverage file stays co-located until a dedicated split preserves behavior and tests.
+import { describe, expect, it } from "vitest";
+import { ancillaryRequestSchema, ancillaryResponseSchema, checkInRequestSchema, checkInResponseSchema, flightAdapterCapabilitiesSchema, flightAdapterContextSchema, flightBookRequestSchema, flightBookResponseSchema, flightCancelResponseSchema, flightGetOrderResponseSchema, flightModifyRequestSchema, flightModifyResponseSchema, flightOrdersListQuerySchema, flightOrdersListResponseSchema, flightPriceRequestSchema, flightPriceResponseSchema, flightRefundRequestSchema, flightRefundResponseSchema, flightSearchRequestSchema, flightSearchResponseSchema, flightVoidResponseSchema, moneySchema, seatMapRequestSchema, seatMapResponseSchema, seatSelectionRequestSchema, seatSelectionResponseSchema, ssrRequestSchema, ssrResponseSchema, } from "./schemas.js";
+const typeChecks = [
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+    true,
+];
+void typeChecks;
+const money = { amount: "600.00", currency: "USD" };
+const segment = {
+    segmentId: "seg_1",
+    carrierCode: "BA",
+    flightNumber: "177",
+    departure: { iataCode: "LHR", terminal: "5", at: "2026-10-15T11:00:00+00:00" },
+    arrival: { iataCode: "JFK", terminal: "8", at: "2026-10-15T14:00:00-04:00" },
+    aircraft: "777",
+    cabin: "economy",
+    providerData: { source: "fixture" },
+};
+const offer = {
+    offerId: "offer_1",
+    source: "test",
+    itineraries: [{ segments: [segment], duration: "PT8H" }],
+    fareBreakdowns: [
+        {
+            passengerType: "adult",
+            passengerCount: 1,
+            baseFare: { amount: "500.00", currency: "USD" },
+            taxes: { amount: "100.00", currency: "USD" },
+            total: money,
+        },
+    ],
+    totalPrice: money,
+    validatingCarrier: "BA",
+    expiresAt: "2026-10-01T11:00:00Z",
+    lastTicketingDate: "2026-10-02",
+    fareBundles: [
+        {
+            id: "standard",
+            label: "Standard",
+            tier: "standard",
+            priceDelta: { amount: "30.00", currency: "USD" },
+            inclusions: {
+                cabinBag: { included: true, weightKg: 8 },
+                seatSelection: "standard",
+            },
+        },
+    ],
+};
+const passenger = {
+    passengerId: "pax_1",
+    type: "adult",
+    firstName: "Ada",
+    lastName: "Lovelace",
+    dateOfBirth: "1980-01-01",
+    documents: [
+        {
+            type: "passport",
+            number: "123456789",
+            countryOfIssue: "GB",
+            expiryDate: "2030-01-01",
+        },
+    ],
+};
+const order = {
+    orderId: "order_1",
+    pnr: "ABC123",
+    status: "ticketed",
+    offer,
+    passengers: [passenger],
+    contact: { email: "ada@example.com" },
+    tickets: [{ ticketNumber: "1250000000001", passengerId: "pax_1", segmentIds: ["seg_1"] }],
+    totalPrice: money,
+    createdAt: "2026-10-01T10:00:00Z",
+    providerData: { locator: "ABC123" },
+};
+const ancillarySelection = {
+    baggage: [{ passengerId: "pax_1", sliceIndex: 0, optionId: "bag_20kg", quantity: 1 }],
+    seats: [{ passengerId: "pax_1", segmentId: "seg_1", seatNumber: "12A" }],
+};
+const seatMap = {
+    segmentId: "seg_1",
+    aircraft: "777",
+    cabin: "economy",
+    columnLayout: ["A", "B", "C", null, "D", "E", "F"],
+    rows: [
+        {
+            row: 12,
+            seats: [
+                {
+                    seatNumber: "12A",
+                    row: 12,
+                    column: "A",
+                    status: "available",
+                    category: "standard",
+                    window: true,
+                },
+            ],
+        },
+    ],
+};
+const logger = {
+    debug() { },
+    info() { },
+    warn() { },
+    error() { },
+};
+const roundTripCases = [
+    [
+        "flightSearchRequestSchema",
+        flightSearchRequestSchema,
+        {
+            slices: [{ origin: "LHR", destination: "JFK", departureDate: "2026-10-15" }],
+            passengers: { adults: 1 },
+            cabin: "economy",
+        },
+    ],
+    ["flightSearchResponseSchema", flightSearchResponseSchema, { offers: [offer] }],
+    ["flightPriceRequestSchema", flightPriceRequestSchema, { offerId: "offer_1", offer }],
+    ["flightPriceResponseSchema", flightPriceResponseSchema, { offer, valid: true }],
+    [
+        "flightBookRequestSchema",
+        flightBookRequestSchema,
+        {
+            offerId: "offer_1",
+            offer,
+            passengers: [passenger],
+            paymentIntent: { type: "hold" },
+            ancillaries: ancillarySelection,
+        },
+    ],
+    ["flightBookResponseSchema", flightBookResponseSchema, { order }],
+    ["flightGetOrderResponseSchema", flightGetOrderResponseSchema, { order }],
+    ["flightCancelResponseSchema", flightCancelResponseSchema, { order, refundedAmount: money }],
+    [
+        "flightOrdersListQuerySchema",
+        flightOrdersListQuerySchema,
+        { cursor: "next", limit: 20, status: ["ticketed"], search: "ABC" },
+    ],
+    [
+        "flightOrdersListResponseSchema",
+        flightOrdersListResponseSchema,
+        { orders: [order], pagination: { total: 1, hasMore: false } },
+    ],
+    ["ancillaryRequestSchema", ancillaryRequestSchema, { offerId: "offer_1", offer }],
+    [
+        "ancillaryResponseSchema",
+        ancillaryResponseSchema,
+        {
+            catalog: {
+                baggage: [{ id: "bag_20kg", label: "20kg bag", category: "checked", price: money }],
+                assistance: [{ id: "wchr", label: "Wheelchair", category: "wheelchair" }],
+                extras: [{ id: "priority", label: "Priority", category: "boarding", price: money }],
+            },
+            validUntil: "2026-10-01T11:00:00Z",
+        },
+    ],
+    ["seatMapRequestSchema", seatMapRequestSchema, { offerId: "offer_1", segmentId: "seg_1", offer }],
+    ["seatMapResponseSchema", seatMapResponseSchema, { seatMap }],
+    [
+        "seatSelectionRequestSchema",
+        seatSelectionRequestSchema,
+        {
+            orderId: "order_1",
+            selections: [{ passengerId: "pax_1", segmentId: "seg_1", seatNumber: "12A" }],
+        },
+    ],
+    [
+        "seatSelectionResponseSchema",
+        seatSelectionResponseSchema,
+        { order, selections: [{ passengerId: "pax_1", segmentId: "seg_1", seatNumber: "12A" }] },
+    ],
+    ["checkInRequestSchema", checkInRequestSchema, { orderId: "order_1", passengerIds: ["pax_1"] }],
+    [
+        "checkInResponseSchema",
+        checkInResponseSchema,
+        {
+            order,
+            status: "checked_in",
+            boardingPasses: [{ passengerId: "pax_1", segmentId: "seg_1", seatNumber: "12A" }],
+        },
+    ],
+    [
+        "flightModifyRequestSchema",
+        flightModifyRequestSchema,
+        { orderId: "order_1", ancillaries: ancillarySelection },
+    ],
+    [
+        "flightModifyResponseSchema",
+        flightModifyResponseSchema,
+        { order, priceDifference: { amount: "-25.00", currency: "USD" } },
+    ],
+    [
+        "flightRefundRequestSchema",
+        flightRefundRequestSchema,
+        { orderId: "order_1", reason: "customer_request" },
+    ],
+    ["flightRefundResponseSchema", flightRefundResponseSchema, { order, refundedAmount: money }],
+    [
+        "flightVoidResponseSchema",
+        flightVoidResponseSchema,
+        { order, voidedAt: "2026-10-01T11:00:00Z" },
+    ],
+    [
+        "ssrRequestSchema",
+        ssrRequestSchema,
+        { orderId: "order_1", code: "WCHR", passengerIds: ["pax_1"] },
+    ],
+    ["ssrResponseSchema", ssrResponseSchema, { order, status: "requested" }],
+    [
+        "flightAdapterContextSchema",
+        flightAdapterContextSchema,
+        { connectionId: "conn_1", logger, environment: "sandbox" },
+    ],
+    [
+        "flightAdapterCapabilitiesSchema",
+        flightAdapterCapabilitiesSchema,
+        { provider: "demo", declared: ["flight/holds"], maxSlicesPerSearch: 2 },
+    ],
+];
+const invalidCases = [
+    ["moneySchema", moneySchema, { amount: 600, currency: "USD" }],
+    [
+        "flightSearchRequestSchema",
+        flightSearchRequestSchema,
+        { slices: [], passengers: { adults: -1 } },
+    ],
+    ["flightSearchResponseSchema", flightSearchResponseSchema, { offers: [{ totalPrice: money }] }],
+    ["flightPriceRequestSchema", flightPriceRequestSchema, { offerId: 123 }],
+    ["flightPriceResponseSchema", flightPriceResponseSchema, { offer, valid: "yes" }],
+    ["flightBookRequestSchema", flightBookRequestSchema, { offerId: "offer_1", passengers: [{}] }],
+    [
+        "flightBookResponseSchema",
+        flightBookResponseSchema,
+        { order: { ...order, status: "unknown" } },
+    ],
+    [
+        "flightGetOrderResponseSchema",
+        flightGetOrderResponseSchema,
+        { order: { ...order, totalPrice: { amount: "x", currency: "USD" } } },
+    ],
+    [
+        "flightCancelResponseSchema",
+        flightCancelResponseSchema,
+        { order, refundedAmount: { amount: "1.00", currency: "US" } },
+    ],
+    ["flightOrdersListQuerySchema", flightOrdersListQuerySchema, { limit: 0 }],
+    [
+        "flightOrdersListResponseSchema",
+        flightOrdersListResponseSchema,
+        { orders: [order], pagination: { total: -1, hasMore: false } },
+    ],
+    ["ancillaryRequestSchema", ancillaryRequestSchema, { offerId: 123 }],
+    [
+        "ancillaryResponseSchema",
+        ancillaryResponseSchema,
+        { catalog: { baggage: [], assistance: [] } },
+    ],
+    ["seatMapRequestSchema", seatMapRequestSchema, { offerId: "offer_1" }],
+    ["seatMapResponseSchema", seatMapResponseSchema, { seatMap: { ...seatMap, cabin: "sofa" } }],
+    [
+        "seatSelectionRequestSchema",
+        seatSelectionRequestSchema,
+        { orderId: "order_1", selections: [{ seatNumber: "12A" }] },
+    ],
+    [
+        "seatSelectionResponseSchema",
+        seatSelectionResponseSchema,
+        { order, selections: [{ passengerId: "pax_1" }] },
+    ],
+    ["checkInRequestSchema", checkInRequestSchema, { passengerIds: ["pax_1"] }],
+    ["checkInResponseSchema", checkInResponseSchema, { order, status: "done" }],
+    [
+        "flightModifyRequestSchema",
+        flightModifyRequestSchema,
+        { orderId: "order_1", reason: "vacation" },
+    ],
+    [
+        "flightModifyResponseSchema",
+        flightModifyResponseSchema,
+        { order, penalties: [{ amount: "1.00", currency: "US" }] },
+    ],
+    [
+        "flightRefundRequestSchema",
+        flightRefundRequestSchema,
+        { orderId: "order_1", reason: "changed_mind" },
+    ],
+    [
+        "flightRefundResponseSchema",
+        flightRefundResponseSchema,
+        { order, refundedAmount: { amount: "x", currency: "USD" } },
+    ],
+    ["flightVoidResponseSchema", flightVoidResponseSchema, { order }],
+    ["ssrRequestSchema", ssrRequestSchema, { orderId: "order_1", code: "NOPE" }],
+    ["ssrResponseSchema", ssrResponseSchema, { order, status: "done" }],
+    [
+        "flightAdapterCapabilitiesSchema",
+        flightAdapterCapabilitiesSchema,
+        { provider: "demo", declared: ["flight/nope"] },
+    ],
+    [
+        "flightAdapterContextSchema",
+        flightAdapterContextSchema,
+        { connectionId: "conn_1", logger: {} },
+    ],
+];
+describe("flight contract schemas", () => {
+    it.each(roundTripCases)("parses %s fixtures without changing shape", (_name, schema, value) => {
+        expect(schema.parse(value)).toEqual(value);
+    });
+    it.each(invalidCases)("rejects invalid %s fixtures", (_name, schema, value) => {
+        expect(schema.safeParse(value).success).toBe(false);
+    });
+});

package/dist/contract/types.d.ts

@@ -0,0 +1,2 @@
+export * from "@voyant-travel/flights-contracts/contract/types";
+//# sourceMappingURL=types.d.ts.map

package/dist/contract/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/contract/types.ts"],"names":[],"mappings":"AAAA,cAAc,iDAAiD,CAAA"}

package/dist/contract/types.js

@@ -0,0 +1 @@
+export * from "@voyant-travel/flights-contracts/contract/types";

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { type AdapterLogger, CAPABILITY_NOT_SUPPORTED, type FlightAdapterCapabilities, type FlightAdapterContext, type FlightAdapterEnvironment, type FlightBookResponse, type FlightCancelReason, type FlightCancelResponse, FlightCapabilityNotSupportedError, type FlightConnectorAdapter, type FlightGetOrderResponse, type FlightPriceRequest, type FlightPriceResponse, type FlightSearchResponse, requireCapability, } from "./contract/adapter.js";
+export * from "./contract/schemas.js";
+export * from "./contract/types.js";
+export { type ConnectionResult, type ConnectionSearchStatus, type FanOutFlightSearchOptions, type FanOutFlightSearchResult, fanOutFlightSearch, type MergedFlightOffer, } from "./orchestration/fan-out.js";
+export { itineraryFingerprint } from "./orchestration/fingerprint.js";
+export { type Aircraft, type Airline, type Airport, dedupeCodes, type ReferenceDataCapabilities, type ReferenceDataProvider, } from "./reference/contract.js";
+export { createLocalPostgresReferenceProvider, type LocalPostgresReferenceProviderOptions, referenceAircraft, referenceAirlines, referenceAirports, } from "./reference/local-postgres.js";
+export { createStaticBundleReferenceProvider, type StaticBundleProviderOptions, type StaticBundleReferenceData, } from "./reference/static-bundle.js";
+export { type BuildFlightSnapshotInputOptions, buildFlightSnapshotInput, } from "./snapshot.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,aAAa,EAClB,wBAAwB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,iCAAiC,EACjC,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,iBAAiB,GAClB,MAAM,uBAAuB,CAAA;AAC9B,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,kBAAkB,EAClB,KAAK,iBAAiB,GACvB,MAAM,4BAA4B,CAAA;AAEnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AAErE,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,WAAW,EACX,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,GAC3B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,oCAAoC,EACpC,KAAK,qCAAqC,EAC1C,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EACL,mCAAmC,EACnC,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,GAC/B,MAAM,8BAA8B,CAAA;AAErC,OAAO,EACL,KAAK,+BAA+B,EACpC,wBAAwB,GACzB,MAAM,eAAe,CAAA"}

package/dist/index.js

@@ -0,0 +1,14 @@
+// Flight contract types — offers, orders, segments, search, booking.
+// FlightConnectorAdapter contract.
+export { CAPABILITY_NOT_SUPPORTED, FlightCapabilityNotSupportedError, requireCapability, } from "./contract/adapter.js";
+export * from "./contract/schemas.js";
+export * from "./contract/types.js";
+export { fanOutFlightSearch, } from "./orchestration/fan-out.js";
+// Orchestration — fingerprinting + multi-connection fan-out.
+export { itineraryFingerprint } from "./orchestration/fingerprint.js";
+// ReferenceDataProvider — swappable provider for global reference data.
+export { dedupeCodes, } from "./reference/contract.js";
+export { createLocalPostgresReferenceProvider, referenceAircraft, referenceAirlines, referenceAirports, } from "./reference/local-postgres.js";
+export { createStaticBundleReferenceProvider, } from "./reference/static-bundle.js";
+// Snapshot capture for booking-time integration with the catalog plane.
+export { buildFlightSnapshotInput, } from "./snapshot.js";

package/dist/orchestration/fan-out.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Multi-connection fan-out search.
+ *
+ * Parallel `searchFlights` across all of an operator's flight connections
+ * with per-connection timeouts, partial-success handling, and merge by
+ * itinerary fingerprint. Returns a merged result set with the cheapest
+ * offer per itinerary as the primary rank, alternates from other
+ * connections beneath it, and a per-connection status map.
+ *
+ * Implements voyant-cloud's `MergedFlightOffer` shape so consumers see the
+ * same result format regardless of where the orchestration runs.
+ *
+ * See `docs/architecture/catalog-flights-architecture.md` §4.
+ */
+import type { FlightAdapterContext, FlightConnectorAdapter } from "../contract/adapter.js";
+import type { FlightOffer, FlightSearchRequest } from "../contract/types.js";
+/**
+ * One source's result — the primary offer plus alternates from other
+ * connections selling the same flight.
+ */
+export interface MergedFlightOffer {
+    itineraryFingerprint: string;
+    /** Cheapest offer for this itinerary across all responding connections. */
+    cheapest: FlightOffer;
+    /** Other offers for the same itinerary, sorted by total price ascending. */
+    alternates: FlightOffer[];
+    /** Connection ids that returned an offer for this itinerary. */
+    sourceConnectionIds: string[];
+}
+/**
+ * Per-connection status, returned alongside the merged offers so callers
+ * can surface "X provider timed out" without losing the rest of the results.
+ */
+export type ConnectionSearchStatus = "ok" | "timeout" | "error" | "not_found" | "capability_missing";
+export interface ConnectionResult {
+    connectionId: string;
+    status: ConnectionSearchStatus;
+    count: number;
+    latencyMs: number;
+    errorMessage?: string;
+}
+export interface FanOutFlightSearchOptions {
+    /** Adapters to fan out across. Each carries its own connectionId in capabilities. */
+    adapters: ReadonlyArray<{
+        connectionId: string;
+        adapter: FlightConnectorAdapter;
+        /** Optional override for the adapter context per connection. */
+        context?: Partial<FlightAdapterContext>;
+    }>;
+    request: FlightSearchRequest;
+    /**
+     * Per-connection timeout. Default 5000ms. One slow provider doesn't
+     * tank the whole search — its slot is reported as `timeout` and other
+     * results return on time.
+     */
+    perConnectionTimeoutMs?: number;
+    /**
+     * Optional caller-supplied limit on the merged offer count. The fan-out
+     * still queries every connection in full; this caps the merged result.
+     */
+    limit?: number;
+}
+export interface FanOutFlightSearchResult {
+    offers: MergedFlightOffer[];
+    perConnection: ConnectionResult[];
+}
+/**
+ * Fan out a flight search across an operator's connections, parallelized
+ * with per-connection timeout, then merge by itinerary fingerprint.
+ *
+ * Partial-success semantics: connections that time out / error / report
+ * capability-missing are flagged in `perConnection`; the orchestration
+ * still returns whatever responding connections produced.
+ */
+export declare function fanOutFlightSearch(options: FanOutFlightSearchOptions): Promise<FanOutFlightSearchResult>;
+interface ConnectionFanOutOk {
+    connectionId: string;
+    offers: FlightOffer[];
+}
+export type { ConnectionFanOutOk };
+//# sourceMappingURL=fan-out.d.ts.map

package/dist/orchestration/fan-out.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fan-out.d.ts","sourceRoot":"","sources":["../../src/orchestration/fan-out.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAC1F,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAG5E;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,EAAE,MAAM,CAAA;IAC5B,2EAA2E;IAC3E,QAAQ,EAAE,WAAW,CAAA;IACrB,4EAA4E;IAC5E,UAAU,EAAE,WAAW,EAAE,CAAA;IACzB,gEAAgE;IAChE,mBAAmB,EAAE,MAAM,EAAE,CAAA;CAC9B;AAED;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,oBAAoB,CAAA;AAEpG,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,sBAAsB,CAAA;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,yBAAyB;IACxC,qFAAqF;IACrF,QAAQ,EAAE,aAAa,CAAC;QACtB,YAAY,EAAE,MAAM,CAAA;QACpB,OAAO,EAAE,sBAAsB,CAAA;QAC/B,gEAAgE;QAChE,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAA;KACxC,CAAC,CAAA;IACF,OAAO,EAAE,mBAAmB,CAAA;IAC5B;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,iBAAiB,EAAE,CAAA;IAC3B,aAAa,EAAE,gBAAgB,EAAE,CAAA;CAClC;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAgEnC;AAED,UAAU,kBAAkB;IAC1B,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,WAAW,EAAE,CAAA;CACtB;AAyED,YAAY,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/orchestration/fan-out.js

@@ -0,0 +1,132 @@
+/**
+ * Multi-connection fan-out search.
+ *
+ * Parallel `searchFlights` across all of an operator's flight connections
+ * with per-connection timeouts, partial-success handling, and merge by
+ * itinerary fingerprint. Returns a merged result set with the cheapest
+ * offer per itinerary as the primary rank, alternates from other
+ * connections beneath it, and a per-connection status map.
+ *
+ * Implements voyant-cloud's `MergedFlightOffer` shape so consumers see the
+ * same result format regardless of where the orchestration runs.
+ *
+ * See `docs/architecture/catalog-flights-architecture.md` §4.
+ */
+import { itineraryFingerprint } from "./fingerprint.js";
+/**
+ * Fan out a flight search across an operator's connections, parallelized
+ * with per-connection timeout, then merge by itinerary fingerprint.
+ *
+ * Partial-success semantics: connections that time out / error / report
+ * capability-missing are flagged in `perConnection`; the orchestration
+ * still returns whatever responding connections produced.
+ */
+export async function fanOutFlightSearch(options) {
+    const timeoutMs = options.perConnectionTimeoutMs ?? 5000;
+    const settled = await Promise.all(options.adapters.map(async ({ connectionId, adapter, context }) => {
+        const start = Date.now();
+        try {
+            // Capability check up front. If the adapter declares a max-slices
+            // limit and the request exceeds it, fail fast as `capability_missing`.
+            const max = adapter.capabilities.maxSlicesPerSearch;
+            if (max != null && options.request.slices.length > max) {
+                return {
+                    connectionId,
+                    status: "capability_missing",
+                    offers: [],
+                    latencyMs: Date.now() - start,
+                    errorMessage: `Connection supports max ${max} slices; request had ${options.request.slices.length}`,
+                };
+            }
+            const ctx = { connectionId, ...context };
+            const response = await withTimeout(adapter.searchFlights(ctx, options.request), timeoutMs, `connection ${connectionId} timed out after ${timeoutMs}ms`);
+            return {
+                connectionId,
+                status: "ok",
+                offers: response.offers,
+                latencyMs: Date.now() - start,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const isTimeout = message.includes("timed out");
+            return {
+                connectionId,
+                status: isTimeout ? "timeout" : "error",
+                offers: [],
+                latencyMs: Date.now() - start,
+                errorMessage: message,
+            };
+        }
+    }));
+    // Build per-connection status report.
+    const perConnection = settled.map((r) => ({
+        connectionId: r.connectionId,
+        status: r.status,
+        count: r.offers.length,
+        latencyMs: r.latencyMs,
+        errorMessage: r.errorMessage,
+    }));
+    // Group offers by itinerary fingerprint, building MergedFlightOffer per group.
+    const merged = mergeByFingerprint(settled);
+    // Sort merged offers by cheapest price ascending.
+    merged.sort((a, b) => compareMoney(a.cheapest.totalPrice, b.cheapest.totalPrice));
+    const limited = options.limit != null ? merged.slice(0, options.limit) : merged;
+    return { offers: limited, perConnection };
+}
+function mergeByFingerprint(results) {
+    const buckets = new Map();
+    for (const { connectionId, offers } of results) {
+        for (const offer of offers) {
+            const key = itineraryFingerprint(offer);
+            const bucket = buckets.get(key);
+            if (bucket) {
+                bucket.offers.push({ connectionId, offer });
+                bucket.sourceConnectionIds.add(connectionId);
+            }
+            else {
+                buckets.set(key, {
+                    offers: [{ connectionId, offer }],
+                    sourceConnectionIds: new Set([connectionId]),
+                });
+            }
+        }
+    }
+    const merged = [];
+    for (const [fingerprint, bucket] of buckets) {
+        // Sort offers within the bucket by total price ascending.
+        bucket.offers.sort((a, b) => compareMoney(a.offer.totalPrice, b.offer.totalPrice));
+        const cheapestEntry = bucket.offers[0];
+        if (!cheapestEntry)
+            continue;
+        merged.push({
+            itineraryFingerprint: fingerprint,
+            cheapest: cheapestEntry.offer,
+            alternates: bucket.offers.slice(1).map((entry) => entry.offer),
+            sourceConnectionIds: Array.from(bucket.sourceConnectionIds),
+        });
+    }
+    return merged;
+}
+/**
+ * Compare two `Money` values. Currencies must match — cross-currency
+ * comparison would require live FX which the orchestration doesn't have.
+ * Returns negative if `a < b`, positive if `a > b`, 0 if equal.
+ */
+function compareMoney(a, b) {
+    if (a.currency !== b.currency) {
+        // Fall back to string compare on amount when currencies differ —
+        // produces a stable but not-meaningful order. Real deployments
+        // normalize currency upstream of the orchestration.
+        return a.amount.localeCompare(b.amount);
+    }
+    const aNum = Number.parseFloat(a.amount);
+    const bNum = Number.parseFloat(b.amount);
+    return aNum - bNum;
+}
+async function withTimeout(promise, ms, message) {
+    return await Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(message)), ms)),
+    ]);
+}

package/dist/orchestration/fan-out.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fan-out.test.d.ts.map

package/dist/orchestration/fan-out.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fan-out.test.d.ts","sourceRoot":"","sources":["../../src/orchestration/fan-out.test.ts"],"names":[],"mappings":""}