@voyant-travel/catalog 0.117.2

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

@@ -0,0 +1,455 @@
+/**
+ * `catalog_quotes` — short-lived quote records the booking engine writes
+ * before a `bookEntity` call validates and consumes them.
+ *
+ * One quote = one (entity_module, entity_id, scope) combination at a
+ * specific time, with an `expires_at` driven by the engine's quote TTL
+ * (default 10 minutes). Re-quoting the same row produces a new row;
+ * quotes are not de-duped.
+ *
+ * The structured columns mirror `booking_catalog_snapshot`'s pricing
+ * layout so finance can read both shapes without parsing JSONB.
+ *
+ * Plain text references (no FK) preserve the cross-module decoupling
+ * rule from `schema-discipline.md`.
+ */
+import type { AppliedOffer } from "./promotions-contract.js";
+export declare const catalogQuotesTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "catalog_quotes";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "catalog_quotes";
+            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: "catalog_quotes";
+            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: "catalog_quotes";
+            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: "catalog_quotes";
+            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_provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_provider";
+            tableName: "catalog_quotes";
+            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_connection_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_connection_id";
+            tableName: "catalog_quotes";
+            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: "catalog_quotes";
+            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;
+        }, {}, {}>;
+        available: import("drizzle-orm/pg-core").PgColumn<{
+            name: "available";
+            tableName: "catalog_quotes";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        invalid_reason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "invalid_reason";
+            tableName: "catalog_quotes";
+            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;
+        }, {}, {}>;
+        locale: import("drizzle-orm/pg-core").PgColumn<{
+            name: "locale";
+            tableName: "catalog_quotes";
+            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;
+        }, {}, {}>;
+        audience: import("drizzle-orm/pg-core").PgColumn<{
+            name: "audience";
+            tableName: "catalog_quotes";
+            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;
+        }, {}, {}>;
+        market: import("drizzle-orm/pg-core").PgColumn<{
+            name: "market";
+            tableName: "catalog_quotes";
+            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;
+        }, {}, {}>;
+        currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency";
+            tableName: "catalog_quotes";
+            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;
+        }, {}, {}>;
+        pricing_base_amount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_base_amount";
+            tableName: "catalog_quotes";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_taxes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_taxes";
+            tableName: "catalog_quotes";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_fees: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_fees";
+            tableName: "catalog_quotes";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_surcharges: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_surcharges";
+            tableName: "catalog_quotes";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        pricing_currency: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_currency";
+            tableName: "catalog_quotes";
+            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;
+        }, {}, {}>;
+        pricing_breakdown: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_breakdown";
+            tableName: "catalog_quotes";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        pricing_applied_offers: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pricing_applied_offers";
+            tableName: "catalog_quotes";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: AppliedOffer[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: AppliedOffer[];
+        }>;
+        upstream_payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "upstream_payload";
+            tableName: "catalog_quotes";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        consumed_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consumed_at";
+            tableName: "catalog_quotes";
+            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: "catalog_quotes";
+            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: "catalog_quotes";
+            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: "catalog_quotes";
+            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 SelectCatalogQuote = typeof catalogQuotesTable.$inferSelect;
+export type InsertCatalogQuote = typeof catalogQuotesTable.$inferInsert;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/booking-engine/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqE9B,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/schema.js

@@ -0,0 +1,75 @@
+/**
+ * `catalog_quotes` — short-lived quote records the booking engine writes
+ * before a `bookEntity` call validates and consumes them.
+ *
+ * One quote = one (entity_module, entity_id, scope) combination at a
+ * specific time, with an `expires_at` driven by the engine's quote TTL
+ * (default 10 minutes). Re-quoting the same row produces a new row;
+ * quotes are not de-duped.
+ *
+ * The structured columns mirror `booking_catalog_snapshot`'s pricing
+ * layout so finance can read both shapes without parsing JSONB.
+ *
+ * Plain text references (no FK) preserve the cross-module decoupling
+ * rule from `schema-discipline.md`.
+ */
+import { typeId } from "@voyant-travel/db/lib/typeid-column";
+import { boolean, index, jsonb, numeric, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+export const catalogQuotesTable = pgTable("catalog_quotes", {
+    id: typeId("catalog_quotes"),
+    entity_module: text("entity_module").notNull(),
+    entity_id: text("entity_id").notNull(),
+    /** Mirrors the snapshot row's source pointer so a book can echo it back. */
+    source_kind: text("source_kind").notNull(),
+    source_provider: text("source_provider"),
+    source_connection_id: text("source_connection_id"),
+    source_ref: text("source_ref"),
+    /** Whether the upstream/owned source flagged this entity as bookable. */
+    available: boolean("available").notNull(),
+    /** Populated when `available = false`; carries the upstream reason. */
+    invalid_reason: text("invalid_reason"),
+    /** Locale/audience/market scope captured for the quote. */
+    locale: text("locale").notNull(),
+    audience: text("audience").notNull(),
+    market: text("market").notNull(),
+    currency: text("currency"),
+    /** Pricing breakdown — same shape as `booking_catalog_snapshot`. */
+    pricing_base_amount: numeric("pricing_base_amount", { precision: 18, scale: 4 }),
+    pricing_taxes: numeric("pricing_taxes", { precision: 18, scale: 4 }),
+    pricing_fees: numeric("pricing_fees", { precision: 18, scale: 4 }),
+    pricing_surcharges: numeric("pricing_surcharges", { precision: 18, scale: 4 }),
+    pricing_currency: text("pricing_currency"),
+    pricing_breakdown: jsonb("pricing_breakdown").$type(),
+    /**
+     * Promotional offers applied to this quote. Populated by the
+     * `evaluatePromotions` hook on `QuoteEntityDeps` (per
+     * `docs/architecture/promotions-architecture.md` §7.1.3). The
+     * post-commit redemption recorder reads this back via
+     * `consumed_booking_id` and aggregates into
+     * `promotional_offer_redemptions`.
+     *
+     * Dedicated column (vs. nesting in `pricing_breakdown`) so the
+     * dependency from the redemption recorder to this data is explicit
+     * at the schema level — anyone touching the quote writer sees the
+     * column and knows it has a downstream consumer.
+     */
+    pricing_applied_offers: jsonb("pricing_applied_offers").$type(),
+    /** Opaque adapter payload echoed forward into `bookEntity` if supported. */
+    upstream_payload: jsonb("upstream_payload"),
+    /**
+     * Set when a `bookEntity` call consumes this quote. Consumed quotes
+     * are kept (audit) but rejected on subsequent book calls.
+     */
+    consumed_at: timestamp("consumed_at", { withTimezone: true }),
+    consumed_booking_id: text("consumed_booking_id"),
+    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    expires_at: timestamp("expires_at", { withTimezone: true }).notNull(),
+}, (table) => [
+    index("idx_catalog_quotes_entity").on(table.entity_module, table.entity_id),
+    index("idx_catalog_quotes_expires").on(table.expires_at),
+    index("idx_catalog_quotes_source").on(table.source_kind, table.source_ref),
+    // Lookup index for the post-commit redemption recorder, which scans
+    // for "every quote consumed by this booking" to aggregate
+    // `pricing_applied_offers` per offer.
+    index("idx_catalog_quotes_consumed_booking").on(table.consumed_booking_id),
+]);

package/dist/booking-engine/snapshot-content.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Snapshot content capture per sourced-content §5.1.
+ *
+ * The booking engine calls a `SnapshotContentCapturer` at commit time
+ * to refresh content from the adapter and embed the result in the
+ * snapshot's `frozen_payload.content_capture` envelope. The
+ * capturer's contract is "refresh-with-fallback":
+ *
+ *   1. Try to fetch fresh content from the adapter (and write through
+ *      to the per-vertical content cache so the next read sees the
+ *      fresh row).
+ *   2. On adapter error (network blip, rate limit, transient outage),
+ *      fall back to the cache — including stale rows.
+ *   3. If neither is available, throw `SnapshotContentUnavailableError`.
+ *      The booking engine propagates this and aborts the commit. We
+ *      deliberately do NOT snapshot from the indexed projection —
+ *      refunds and audit need real "what was sold" content, not a
+ *      stub.
+ *
+ * The orchestrator stays in the booking-engine sub-package because the
+ * envelope shape, error types, and integration point all live with
+ * `bookEntity`. Per-vertical content services (products, cruises,
+ * etc.) implement `ContentSnapshotAdapter` and the template wires them
+ * into a single capturer via `composeSnapshotContentCapturer`.
+ *
+ * See `docs/architecture/catalog-sourced-content.md` §5.1.
+ */
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import type { GetContentRequest, GetContentResult, SourceAdapter, SourceAdapterContext } from "../adapter/contract.js";
+import type { SourceAdapterRegistry } from "./registry.js";
+/**
+ * Input the booking engine threads into the capturer. Carries the
+ * entity identity, the snapshot source pointer, and the locale/market
+ * scope from the original quote.
+ */
+export interface SnapshotContentCaptureInput {
+    db: AnyDrizzleDb;
+    entity_module: string;
+    entity_id: string;
+    source_kind: string;
+    source_connection_id?: string;
+    source_ref?: string;
+    locale: string;
+    market?: string;
+    currency?: string;
+    adapterContext: SourceAdapterContext;
+}
+/**
+ * The envelope embedded in `frozen_payload.content_capture`. Carries
+ * provenance so audit can distinguish a fresh capture from a cache
+ * fallback later (refund flows, invoice rendering).
+ */
+export interface SnapshotContentCapture {
+    source: "fresh" | "cache_fallback";
+    fetched_at: Date;
+    fallback_reason?: string;
+    content_etag?: string;
+    content_schema_version: string;
+    content: unknown;
+}
+/**
+ * Per-vertical adapter for snapshot capture: refresh + read-cached.
+ * Each vertical's content service implements this and the template
+ * registers them by `entity_module`. The capturer (built via
+ * `composeSnapshotContentCapturer`) routes calls to the right adapter.
+ */
+export interface ContentSnapshotAdapter {
+    /**
+     * Refresh content from the upstream adapter and write through to the
+     * per-vertical content cache. Returns the fresh `GetContentResult`
+     * on success; throws on adapter error (which the orchestrator
+     * catches to fall back to cache).
+     */
+    refresh(db: AnyDrizzleDb, adapter: SourceAdapter, ctx: SourceAdapterContext, request: GetContentRequest): Promise<GetContentResult>;
+    /**
+     * Read the per-vertical cache row for this entity / locale / market,
+     * INCLUDING stale rows. Returns null if no row exists. Used as the
+     * fallback when `refresh` fails.
+     */
+    readCached(db: AnyDrizzleDb, request: GetContentRequest): Promise<{
+        payload: unknown;
+        content_schema_version: string;
+        fetched_at: Date;
+        etag: string | null;
+    } | null>;
+}
+/**
+ * The function the booking engine receives via
+ * `BookEntityDeps.captureSnapshotContent`. Templates implement this
+ * (typically via `composeSnapshotContentCapturer`) and pass the
+ * resulting function in.
+ *
+ * Returning `null` means "this entity has no sourced content to
+ * capture" (e.g. owned entities) — the engine skips the envelope and
+ * the snapshot keeps its legacy shape.
+ */
+export type SnapshotContentCapturer = (input: SnapshotContentCaptureInput) => Promise<SnapshotContentCapture | null>;
+/**
+ * Compose a `SnapshotContentCapturer` from a registry of per-vertical
+ * `ContentSnapshotAdapter`s and an adapter registry. Use when the
+ * template wants the §5.1 refresh-with-fallback behavior wired
+ * uniformly across verticals.
+ *
+ * Returns null when:
+ *   - The entity_module isn't in the per-vertical adapter map
+ *     (assumed owned or out-of-scope; engine skips the envelope).
+ *   - The source adapter for `source_kind` doesn't implement
+ *     `getContent` AND no cache row exists. (When `getContent` is
+ *     missing but a cache row exists, we serve the cache row — the
+ *     vertical's synthesizer is for read paths, not write paths.)
+ *
+ * Throws `SnapshotContentUnavailableError` when neither fresh nor
+ * cached content can be produced.
+ */
+export declare function composeSnapshotContentCapturer(options: {
+    registry: SourceAdapterRegistry;
+    /** Per-vertical adapters keyed by `entity_module`. */
+    contentAdapters: ReadonlyMap<string, ContentSnapshotAdapter>;
+}): SnapshotContentCapturer;
+//# sourceMappingURL=snapshot-content.d.ts.map

package/dist/booking-engine/snapshot-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-content.d.ts","sourceRoot":"","sources":["../../src/booking-engine/snapshot-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,oBAAoB,EACrB,MAAM,wBAAwB,CAAA;AAG/B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAE1D;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,YAAY,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,cAAc,EAAE,oBAAoB,CAAA;CACrC;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAAA;IAClC,UAAU,EAAE,IAAI,CAAA;IAChB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,sBAAsB,EAAE,MAAM,CAAA;IAC9B,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,OAAO,CACL,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,oBAAoB,EACzB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,gBAAgB,CAAC,CAAA;IAC5B;;;;OAIG;IACH,UAAU,CACR,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAA;QAChB,sBAAsB,EAAE,MAAM,CAAA;QAC9B,UAAU,EAAE,IAAI,CAAA;QAChB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;KACpB,GAAG,IAAI,CAAC,CAAA;CACV;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,uBAAuB,GAAG,CACpC,KAAK,EAAE,2BAA2B,KAC/B,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAA;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE;IACtD,QAAQ,EAAE,qBAAqB,CAAA;IAC/B,sDAAsD;IACtD,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;CAC7D,GAAG,uBAAuB,CAoD1B"}