@voyant-travel/catalog 0.117.2

package/dist/booking-engine/drafts-schema.d.ts

@@ -0,0 +1,302 @@
+/**
+ * `booking_drafts` — server-side draft state for the unified booking
+ * journey. Survives refresh, tab loss, and short walk-aways. On
+ * commit, `consumed_booking_id` points at the materialized booking;
+ * abandoned drafts never produce a `bookings` row.
+ *
+ * Per `docs/architecture/booking-journey-architecture.md` §5.7 +
+ * §12.10 (settled on the sibling-table option B — ships alongside
+ * `booking_session_states` rather than extending it).
+ *
+ * Lifecycle:
+ *   1. Wizard PUTs the draft on every step transition.
+ *   2. Quote requests resolve draft → engine → catalog_quotes.
+ *   3. On commit, the engine writes the bookings row and stamps
+ *      `consumed_booking_id` here.
+ *   4. Abandoned drafts (`expires_at` passed) are reaped by a daily
+ *      job, releasing any associated soft holds first.
+ */
+export declare const bookingDraftsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "booking_drafts";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_module: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_module";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_kind";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_connection_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_connection_id";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_ref: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_ref";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        draft_payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "draft_payload";
+            tableName: "booking_drafts";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        current_step: import("drizzle-orm/pg-core").PgColumn<{
+            name: "current_step";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        current_quote_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "current_quote_id";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hold_expires_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hold_expires_at";
+            tableName: "booking_drafts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        consumed_booking_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consumed_booking_id";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        consumed_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consumed_at";
+            tableName: "booking_drafts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        created_by: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "booking_drafts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        created_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "booking_drafts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updated_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "booking_drafts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expires_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "booking_drafts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type SelectBookingDraft = typeof bookingDraftsTable.$inferSelect;
+export type InsertBookingDraft = typeof bookingDraftsTable.$inferInsert;
+//# sourceMappingURL=drafts-schema.d.ts.map

package/dist/booking-engine/drafts-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drafts-schema.d.ts","sourceRoot":"","sources":["../../src/booking-engine/drafts-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6C9B,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAA;AACvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,YAAY,CAAA"}

package/dist/booking-engine/drafts-schema.js

@@ -0,0 +1,53 @@
+/**
+ * `booking_drafts` — server-side draft state for the unified booking
+ * journey. Survives refresh, tab loss, and short walk-aways. On
+ * commit, `consumed_booking_id` points at the materialized booking;
+ * abandoned drafts never produce a `bookings` row.
+ *
+ * Per `docs/architecture/booking-journey-architecture.md` §5.7 +
+ * §12.10 (settled on the sibling-table option B — ships alongside
+ * `booking_session_states` rather than extending it).
+ *
+ * Lifecycle:
+ *   1. Wizard PUTs the draft on every step transition.
+ *   2. Quote requests resolve draft → engine → catalog_quotes.
+ *   3. On commit, the engine writes the bookings row and stamps
+ *      `consumed_booking_id` here.
+ *   4. Abandoned drafts (`expires_at` passed) are reaped by a daily
+ *      job, releasing any associated soft holds first.
+ */
+import { typeId } from "@voyant-travel/db/lib/typeid-column";
+import { index, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+export const bookingDraftsTable = pgTable("booking_drafts", {
+    id: typeId("booking_drafts"),
+    /** Pointer to the catalog row this draft is for. */
+    entity_module: text("entity_module").notNull(),
+    entity_id: text("entity_id").notNull(),
+    source_kind: text("source_kind").notNull(),
+    source_connection_id: text("source_connection_id"),
+    source_ref: text("source_ref"),
+    /** Full BookingDraft minus pricing — opaque jsonb for forward
+     *  compat. Validated at the route layer against `bookingDraftV1`. */
+    draft_payload: jsonb("draft_payload").$type().notNull(),
+    /** Wizard's current step — diagnostic, not load-bearing. */
+    current_step: text("current_step"),
+    /** Most-recent quote id snapshotted off this draft. */
+    current_quote_id: text("current_quote_id"),
+    /** Adapter-driven; null when no hold is active. */
+    hold_expires_at: timestamp("hold_expires_at", { withTimezone: true }),
+    /** Set on successful commit — the journey is consumed. */
+    consumed_booking_id: text("consumed_booking_id"),
+    consumed_at: timestamp("consumed_at", { withTimezone: true }),
+    /** Author — staff user id for operator-side, anonymous session
+     *  token (or null) for storefront. */
+    created_by: text("created_by"),
+    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    /** Session-abandonment TTL — default 24h, set by the route layer. */
+    expires_at: timestamp("expires_at", { withTimezone: true }).notNull(),
+}, (table) => [
+    index("idx_booking_drafts_entity").on(table.entity_module, table.entity_id),
+    index("idx_booking_drafts_expires").on(table.expires_at),
+    index("idx_booking_drafts_created_by").on(table.created_by),
+    index("idx_booking_drafts_consumed").on(table.consumed_booking_id),
+]);

package/dist/booking-engine/drafts-service.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Service layer over `booking_drafts` — CRUD + lifecycle helpers
+ * the route layer composes. Per booking-journey-architecture §5.7.
+ */
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { type SelectBookingDraft } from "./drafts-schema.js";
+export declare const DEFAULT_DRAFT_TTL_MS: number;
+export interface UpsertDraftInput {
+    /** Draft id — when omitted, a fresh id is generated. */
+    id?: string;
+    entityModule: string;
+    entityId: string;
+    sourceKind: string;
+    sourceConnectionId?: string;
+    sourceRef?: string;
+    draftPayload: Record<string, unknown>;
+    currentStep?: string;
+    currentQuoteId?: string;
+    holdExpiresAt?: Date | null;
+    createdBy?: string | null;
+    ttlMs?: number;
+}
+export declare function createBookingDraft(db: AnyDrizzleDb, input: UpsertDraftInput): Promise<SelectBookingDraft>;
+export declare function getBookingDraft(db: AnyDrizzleDb, id: string): Promise<SelectBookingDraft | null>;
+export interface UpdateDraftPatch {
+    draftPayload?: Record<string, unknown>;
+    currentStep?: string;
+    currentQuoteId?: string | null;
+    holdExpiresAt?: Date | null;
+    refreshTtlMs?: number;
+}
+export declare function updateBookingDraft(db: AnyDrizzleDb, id: string, patch: UpdateDraftPatch): Promise<SelectBookingDraft | null>;
+export declare function markDraftConsumed(db: AnyDrizzleDb, id: string, bookingId: string): Promise<void>;
+/**
+ * Reaper helper — returns ids of drafts that are past TTL and not
+ * yet consumed. Operators can run this in a daily cron and release
+ * any associated holds before deleting.
+ */
+export declare function findExpiredDrafts(db: AnyDrizzleDb, cutoff?: Date): Promise<SelectBookingDraft[]>;
+export declare function deleteBookingDraft(db: AnyDrizzleDb, id: string): Promise<void>;
+//# sourceMappingURL=drafts-service.d.ts.map

package/dist/booking-engine/drafts-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drafts-service.d.ts","sourceRoot":"","sources":["../../src/booking-engine/drafts-service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,oBAAoB,CAAA;AAE3B,eAAO,MAAM,oBAAoB,QAAsB,CAAA;AAEvD,MAAM,WAAW,gBAAgB;IAC/B,wDAAwD;IACxD,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,aAAa,CAAC,EAAE,IAAI,GAAG,IAAI,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,kBAAkB,CAAC,CAgD7B;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAOpC;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,aAAa,CAAC,EAAE,IAAI,GAAG,IAAI,CAAA;IAE3B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAgBpC;AAED,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CASf;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,YAAY,EAChB,MAAM,GAAE,IAAiB,GACxB,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAU/B;AAED,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpF"}

package/dist/booking-engine/drafts-service.js

@@ -0,0 +1,108 @@
+/**
+ * Service layer over `booking_drafts` — CRUD + lifecycle helpers
+ * the route layer composes. Per booking-journey-architecture §5.7.
+ */
+import { newId } from "@voyant-travel/db/lib/typeid";
+import { and, eq, isNull, lt } from "drizzle-orm";
+import { bookingDraftsTable, } from "./drafts-schema.js";
+export const DEFAULT_DRAFT_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+export async function createBookingDraft(db, input) {
+    const id = input.id ?? newId("booking_drafts");
+    const now = new Date();
+    const expiresAt = new Date(now.getTime() + (input.ttlMs ?? DEFAULT_DRAFT_TTL_MS));
+    const values = {
+        id,
+        entity_module: input.entityModule,
+        entity_id: input.entityId,
+        source_kind: input.sourceKind,
+        source_connection_id: input.sourceConnectionId,
+        source_ref: input.sourceRef,
+        draft_payload: input.draftPayload,
+        current_step: input.currentStep,
+        current_quote_id: input.currentQuoteId,
+        hold_expires_at: input.holdExpiresAt ?? null,
+        created_by: input.createdBy ?? null,
+        created_at: now,
+        updated_at: now,
+        expires_at: expiresAt,
+    };
+    // Upsert (not just insert) — the storefront fires multiple PUTs to
+    // the same draft id in quick succession (step transition + live
+    // re-quote), and the route's find-or-create flow can race two
+    // concurrent calls into colliding INSERTs. Rolling the create + on-
+    // conflict update into a single statement makes the route
+    // idempotent regardless of ordering.
+    const [row] = (await db
+        .insert(bookingDraftsTable)
+        .values(values)
+        .onConflictDoUpdate({
+        target: bookingDraftsTable.id,
+        set: {
+            // Refresh the mutable journey state — we DON'T overwrite
+            // `id`, `created_at`, `created_by`, or the entity pointers
+            // on conflict (those are immutable identity).
+            draft_payload: values.draft_payload,
+            current_step: values.current_step,
+            current_quote_id: values.current_quote_id,
+            hold_expires_at: values.hold_expires_at,
+            updated_at: now,
+            expires_at: expiresAt,
+        },
+    })
+        .returning());
+    if (!row)
+        throw new Error("createBookingDraft: insert returned no rows");
+    return row;
+}
+export async function getBookingDraft(db, id) {
+    const rows = (await db
+        .select()
+        .from(bookingDraftsTable)
+        .where(eq(bookingDraftsTable.id, id))
+        .limit(1));
+    return rows[0] ?? null;
+}
+export async function updateBookingDraft(db, id, patch) {
+    const updates = { updated_at: new Date() };
+    if (patch.draftPayload !== undefined)
+        updates.draft_payload = patch.draftPayload;
+    if (patch.currentStep !== undefined)
+        updates.current_step = patch.currentStep;
+    if (patch.currentQuoteId !== undefined)
+        updates.current_quote_id = patch.currentQuoteId;
+    if (patch.holdExpiresAt !== undefined)
+        updates.hold_expires_at = patch.holdExpiresAt;
+    if (patch.refreshTtlMs !== undefined) {
+        updates.expires_at = new Date(Date.now() + patch.refreshTtlMs);
+    }
+    const rows = (await db
+        .update(bookingDraftsTable)
+        .set(updates)
+        .where(eq(bookingDraftsTable.id, id))
+        .returning());
+    return rows[0] ?? null;
+}
+export async function markDraftConsumed(db, id, bookingId) {
+    await db
+        .update(bookingDraftsTable)
+        .set({
+        consumed_booking_id: bookingId,
+        consumed_at: new Date(),
+        updated_at: new Date(),
+    })
+        .where(eq(bookingDraftsTable.id, id));
+}
+/**
+ * Reaper helper — returns ids of drafts that are past TTL and not
+ * yet consumed. Operators can run this in a daily cron and release
+ * any associated holds before deleting.
+ */
+export async function findExpiredDrafts(db, cutoff = new Date()) {
+    return (await db
+        .select()
+        .from(bookingDraftsTable)
+        .where(and(lt(bookingDraftsTable.expires_at, cutoff), isNull(bookingDraftsTable.consumed_booking_id))));
+}
+export async function deleteBookingDraft(db, id) {
+    await db.delete(bookingDraftsTable).where(eq(bookingDraftsTable.id, id));
+}

package/dist/booking-engine/errors.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Stable error codes returned from the booking engine.
+ *
+ * Mirrors the catalog plane's `CAPABILITY_NOT_SUPPORTED` convention:
+ * codes are stable strings, callers branch on them, and each carries a
+ * dedicated `Error` subclass for stack-trace clarity.
+ */
+/** No SourceAdapter was registered for the row's `source.kind`. */
+export declare const NO_ADAPTER_REGISTERED: "NO_ADAPTER_REGISTERED";
+/**
+ * No OwnedBookingHandler was registered for the row's `entity_module`.
+ * Sibling to `NO_ADAPTER_REGISTERED` — sourced rows dispatch through
+ * adapters keyed by connection, owned rows dispatch through handlers
+ * keyed by entity module. Per booking-journey-architecture §6.
+ */
+export declare const NO_HANDLER_REGISTERED: "NO_HANDLER_REGISTERED";
+/** The supplied `quoteId` is unknown or already consumed. */
+export declare const QUOTE_NOT_FOUND: "QUOTE_NOT_FOUND";
+/** The quote's `expires_at` has passed; caller must re-quote. */
+export declare const QUOTE_EXPIRED: "QUOTE_EXPIRED";
+/** The quote's entity_module/entity_id doesn't match the book request. */
+export declare const QUOTE_MISMATCH: "QUOTE_MISMATCH";
+/** The adapter returned `failed` for the requested entity. */
+export declare const RESERVE_FAILED: "RESERVE_FAILED";
+/** No snapshot row exists for the given (booking_id, entity_*). */
+export declare const ORDER_NOT_FOUND: "ORDER_NOT_FOUND";
+/** The order has already been cancelled. */
+export declare const ORDER_ALREADY_CANCELLED: "ORDER_ALREADY_CANCELLED";
+/**
+ * Snapshot content capture failed: neither a fresh adapter fetch nor a
+ * cache fallback produced a content payload. Per sourced-content §5.1,
+ * we deliberately fail the commit rather than snapshot from the
+ * indexed projection — refunds and audit need real "what was sold"
+ * content, not a stub.
+ */
+export declare const SNAPSHOT_CONTENT_UNAVAILABLE: "SNAPSHOT_CONTENT_UNAVAILABLE";
+export type BookingEngineErrorCode = typeof NO_ADAPTER_REGISTERED | typeof NO_HANDLER_REGISTERED | typeof QUOTE_NOT_FOUND | typeof QUOTE_EXPIRED | typeof QUOTE_MISMATCH | typeof RESERVE_FAILED | typeof ORDER_NOT_FOUND | typeof ORDER_ALREADY_CANCELLED | typeof SNAPSHOT_CONTENT_UNAVAILABLE;
+export declare class BookingEngineError extends Error {
+    readonly code: BookingEngineErrorCode;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(code: BookingEngineErrorCode, message: string, context?: Record<string, unknown> | undefined);
+}
+export declare class NoAdapterRegisteredError extends BookingEngineError {
+    /**
+     * Thrown when the registry has no adapter for the given identifier.
+     * The identifier is a connection id when dispatched per-connection
+     * (channel push, sourced bookings with a known connection) or a source
+     * kind when the caller has no connection id (legacy dispatch).
+     */
+    constructor(identifier: string);
+}
+export declare class NoOwnedHandlerRegisteredError extends BookingEngineError {
+    /** Thrown when the owned-handler registry has no entry for the
+     *  given `entity_module`. */
+    constructor(entityModule: string);
+}
+export declare class QuoteExpiredError extends BookingEngineError {
+    constructor(quoteId: string, expiredAt: Date);
+}
+export declare class QuoteMismatchError extends BookingEngineError {
+    constructor(quoteId: string, expected: {
+        entityModule: string;
+        entityId: string;
+    }, actual: {
+        entityModule: string;
+        entityId: string;
+    });
+}
+export declare class ReserveFailedError extends BookingEngineError {
+    readonly upstreamPayload: unknown;
+    readonly sourceKind: string;
+    readonly entityId: string;
+    constructor(upstreamPayload: unknown, sourceKind: string, entityId: string);
+}
+export declare class SnapshotContentUnavailableError extends BookingEngineError {
+    readonly entityModule: string;
+    readonly entityId: string;
+    readonly fallbackReason: string;
+    constructor(entityModule: string, entityId: string, fallbackReason: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/booking-engine/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/booking-engine/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,mEAAmE;AACnE,eAAO,MAAM,qBAAqB,EAAG,uBAAgC,CAAA;AAErE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAG,uBAAgC,CAAA;AAErE,6DAA6D;AAC7D,eAAO,MAAM,eAAe,EAAG,iBAA0B,CAAA;AAEzD,iEAAiE;AACjE,eAAO,MAAM,aAAa,EAAG,eAAwB,CAAA;AAErD,0EAA0E;AAC1E,eAAO,MAAM,cAAc,EAAG,gBAAyB,CAAA;AAEvD,8DAA8D;AAC9D,eAAO,MAAM,cAAc,EAAG,gBAAyB,CAAA;AAEvD,mEAAmE;AACnE,eAAO,MAAM,eAAe,EAAG,iBAA0B,CAAA;AAEzD,4CAA4C;AAC5C,eAAO,MAAM,uBAAuB,EAAG,yBAAkC,CAAA;AAEzE;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,EAAG,8BAAuC,CAAA;AAEnF,MAAM,MAAM,sBAAsB,GAC9B,OAAO,qBAAqB,GAC5B,OAAO,qBAAqB,GAC5B,OAAO,eAAe,GACtB,OAAO,aAAa,GACpB,OAAO,cAAc,GACrB,OAAO,cAAc,GACrB,OAAO,eAAe,GACtB,OAAO,uBAAuB,GAC9B,OAAO,4BAA4B,CAAA;AAEvC,qBAAa,kBAAmB,SAAQ,KAAK;aAEzB,IAAI,EAAE,sBAAsB;aAE5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAFjC,IAAI,EAAE,sBAAsB,EAC5C,OAAO,EAAE,MAAM,EACC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAKpD;AAED,qBAAa,wBAAyB,SAAQ,kBAAkB;IAC9D;;;;;OAKG;gBACS,UAAU,EAAE,MAAM;CAM/B;AAED,qBAAa,6BAA8B,SAAQ,kBAAkB;IACnE;iCAC6B;gBACjB,YAAY,EAAE,MAAM;CAMjC;AAED,qBAAa,iBAAkB,SAAQ,kBAAkB;gBAC3C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI;CAO7C;AAED,qBAAa,kBAAmB,SAAQ,kBAAkB;gBAEtD,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EACpD,MAAM,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE;CASrD;AAED,qBAAa,kBAAmB,SAAQ,kBAAkB;aAEtC,eAAe,EAAE,OAAO;aACxB,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;gBAFhB,eAAe,EAAE,OAAO,EACxB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM;CASnC;AAED,qBAAa,+BAAgC,SAAQ,kBAAkB;aAEnD,YAAY,EAAE,MAAM;aACpB,QAAQ,EAAE,MAAM;aAChB,cAAc,EAAE,MAAM;gBAFtB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM;CASzC"}