@voyant-travel/inventory 0.1.0

package/dist/booking-extension.d.ts

@@ -0,0 +1,278 @@
+import type { HonoExtension } from "@voyant-travel/hono/module";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { z } from "zod";
+export declare const bookingProductDetails: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "booking_product_details";
+    schema: undefined;
+    columns: {
+        bookingId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "booking_id";
+            tableName: "booking_product_details";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "booking_product_details";
+            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;
+        }, {}, {}>;
+        optionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "option_id";
+            tableName: "booking_product_details";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "booking_product_details";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "booking_product_details";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type BookingProductDetail = typeof bookingProductDetails.$inferSelect;
+export type NewBookingProductDetail = typeof bookingProductDetails.$inferInsert;
+export declare const bookingItemProductDetails: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "booking_item_product_details";
+    schema: undefined;
+    columns: {
+        bookingItemId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "booking_item_id";
+            tableName: "booking_item_product_details";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "booking_item_product_details";
+            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;
+        }, {}, {}>;
+        optionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "option_id";
+            tableName: "booking_item_product_details";
+            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;
+        }, {}, {}>;
+        unitId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "unit_id";
+            tableName: "booking_item_product_details";
+            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;
+        }, {}, {}>;
+        supplierServiceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "supplier_service_id";
+            tableName: "booking_item_product_details";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "booking_item_product_details";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "booking_item_product_details";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type BookingItemProductDetail = typeof bookingItemProductDetails.$inferSelect;
+export type NewBookingItemProductDetail = typeof bookingItemProductDetails.$inferInsert;
+declare const bookingProductDetailSchema: z.ZodObject<{
+    productId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    optionId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const bookingItemProductDetailSchema: z.ZodObject<{
+    productId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    optionId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    unitId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    supplierServiceId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const bookingProductExtensionService: {
+    getBookingDetails(db: PostgresJsDatabase, bookingId: string): Promise<{
+        bookingId: string;
+        productId: string | null;
+        optionId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    upsertBookingDetails(db: PostgresJsDatabase, bookingId: string, data: z.infer<typeof bookingProductDetailSchema>): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string | null;
+        optionId: string | null;
+        bookingId: string;
+    } | null>;
+    removeBookingDetails(db: PostgresJsDatabase, bookingId: string): Promise<{
+        bookingId: string;
+    } | null>;
+    getItemDetails(db: PostgresJsDatabase, bookingItemId: string): Promise<{
+        bookingItemId: string;
+        productId: string | null;
+        optionId: string | null;
+        unitId: string | null;
+        supplierServiceId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    upsertItemDetails(db: PostgresJsDatabase, bookingItemId: string, data: z.infer<typeof bookingItemProductDetailSchema>): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string | null;
+        optionId: string | null;
+        unitId: string | null;
+        supplierServiceId: string | null;
+        bookingItemId: string;
+    } | null>;
+    removeItemDetails(db: PostgresJsDatabase, bookingItemId: string): Promise<{
+        bookingItemId: string;
+    } | null>;
+};
+export declare const productsBookingExtension: HonoExtension;
+export {};
+//# sourceMappingURL=booking-extension.d.ts.map

package/dist/booking-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booking-extension.d.ts","sourceRoot":"","sources":["../src/booking-extension.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAG/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUjC,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAC5E,MAAM,MAAM,uBAAuB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAA;AAE/E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBrC,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,OAAO,yBAAyB,CAAC,YAAY,CAAA;AACpF,MAAM,MAAM,2BAA2B,GAAG,OAAO,yBAAyB,CAAC,YAAY,CAAA;AAIvF,QAAA,MAAM,0BAA0B;;;iBAG9B,CAAA;AAEF,QAAA,MAAM,8BAA8B;;;;;iBAKlC,CAAA;AAIF,eAAO,MAAM,8BAA8B;0BACb,kBAAkB,aAAa,MAAM;;;;;;;6BAU3D,kBAAkB,aACX,MAAM,QACX,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC;;;;;;;6BAqBnB,kBAAkB,aAAa,MAAM;;;uBAQ3C,kBAAkB,iBAAiB,MAAM;;;;;;;;;0BAU5D,kBAAkB,iBACP,MAAM,QACf,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC;;;;;;;;;0BAyB1B,kBAAkB,iBAAiB,MAAM;;;CAOtE,CAAA;AAoFD,eAAO,MAAM,wBAAwB,EAAE,aAGtC,CAAA"}

package/dist/booking-extension.js

@@ -0,0 +1,161 @@
+import { parseJsonBody } from "@voyant-travel/hono";
+import { eq } from "drizzle-orm";
+import { index, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { Hono } from "hono";
+import { z } from "zod";
+// ---------- schemas ----------
+export const bookingProductDetails = pgTable("booking_product_details", {
+    bookingId: text("booking_id").primaryKey(),
+    productId: text("product_id"),
+    optionId: text("option_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (t) => [index("idx_bpd_product").on(t.productId), index("idx_bpd_option").on(t.optionId)]);
+export const bookingItemProductDetails = pgTable("booking_item_product_details", {
+    bookingItemId: text("booking_item_id").primaryKey(),
+    productId: text("product_id"),
+    optionId: text("option_id"),
+    unitId: text("unit_id"),
+    supplierServiceId: text("supplier_service_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (t) => [
+    index("idx_bipd_product").on(t.productId),
+    index("idx_bipd_option").on(t.optionId),
+    index("idx_bipd_unit").on(t.unitId),
+    index("idx_bipd_supplier_service").on(t.supplierServiceId),
+]);
+// ---------- validation ----------
+const bookingProductDetailSchema = z.object({
+    productId: z.string().optional().nullable(),
+    optionId: z.string().optional().nullable(),
+});
+const bookingItemProductDetailSchema = z.object({
+    productId: z.string().optional().nullable(),
+    optionId: z.string().optional().nullable(),
+    unitId: z.string().optional().nullable(),
+    supplierServiceId: z.string().optional().nullable(),
+});
+// ---------- service ----------
+export const bookingProductExtensionService = {
+    async getBookingDetails(db, bookingId) {
+        const [row] = await db
+            .select()
+            .from(bookingProductDetails)
+            .where(eq(bookingProductDetails.bookingId, bookingId))
+            .limit(1);
+        return row ?? null;
+    },
+    async upsertBookingDetails(db, bookingId, data) {
+        const [row] = await db
+            .insert(bookingProductDetails)
+            .values({
+            bookingId,
+            productId: data.productId ?? null,
+            optionId: data.optionId ?? null,
+        })
+            .onConflictDoUpdate({
+            target: bookingProductDetails.bookingId,
+            set: {
+                productId: data.productId ?? null,
+                optionId: data.optionId ?? null,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return row ?? null;
+    },
+    async removeBookingDetails(db, bookingId) {
+        const [row] = await db
+            .delete(bookingProductDetails)
+            .where(eq(bookingProductDetails.bookingId, bookingId))
+            .returning({ bookingId: bookingProductDetails.bookingId });
+        return row ?? null;
+    },
+    async getItemDetails(db, bookingItemId) {
+        const [row] = await db
+            .select()
+            .from(bookingItemProductDetails)
+            .where(eq(bookingItemProductDetails.bookingItemId, bookingItemId))
+            .limit(1);
+        return row ?? null;
+    },
+    async upsertItemDetails(db, bookingItemId, data) {
+        const [row] = await db
+            .insert(bookingItemProductDetails)
+            .values({
+            bookingItemId,
+            productId: data.productId ?? null,
+            optionId: data.optionId ?? null,
+            unitId: data.unitId ?? null,
+            supplierServiceId: data.supplierServiceId ?? null,
+        })
+            .onConflictDoUpdate({
+            target: bookingItemProductDetails.bookingItemId,
+            set: {
+                productId: data.productId ?? null,
+                optionId: data.optionId ?? null,
+                unitId: data.unitId ?? null,
+                supplierServiceId: data.supplierServiceId ?? null,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return row ?? null;
+    },
+    async removeItemDetails(db, bookingItemId) {
+        const [row] = await db
+            .delete(bookingItemProductDetails)
+            .where(eq(bookingItemProductDetails.bookingItemId, bookingItemId))
+            .returning({ bookingItemId: bookingItemProductDetails.bookingItemId });
+        return row ?? null;
+    },
+};
+const bookingProductExtensionRoutes = new Hono()
+    .get("/:bookingId/product-details", async (c) => {
+    const row = await bookingProductExtensionService.getBookingDetails(c.get("db"), c.req.param("bookingId"));
+    if (!row) {
+        return c.json({ data: null });
+    }
+    return c.json({ data: row });
+})
+    .put("/:bookingId/product-details", async (c) => {
+    const data = await parseJsonBody(c, bookingProductDetailSchema);
+    const row = await bookingProductExtensionService.upsertBookingDetails(c.get("db"), c.req.param("bookingId"), data);
+    return c.json({ data: row });
+})
+    .delete("/:bookingId/product-details", async (c) => {
+    const row = await bookingProductExtensionService.removeBookingDetails(c.get("db"), c.req.param("bookingId"));
+    if (!row) {
+        return c.json({ error: "Not found" }, 404);
+    }
+    return c.json({ success: true });
+})
+    .get("/:bookingId/items/:itemId/product-details", async (c) => {
+    const row = await bookingProductExtensionService.getItemDetails(c.get("db"), c.req.param("itemId"));
+    if (!row) {
+        return c.json({ data: null });
+    }
+    return c.json({ data: row });
+})
+    .put("/:bookingId/items/:itemId/product-details", async (c) => {
+    const data = await parseJsonBody(c, bookingItemProductDetailSchema);
+    const row = await bookingProductExtensionService.upsertItemDetails(c.get("db"), c.req.param("itemId"), data);
+    return c.json({ data: row });
+})
+    .delete("/:bookingId/items/:itemId/product-details", async (c) => {
+    const row = await bookingProductExtensionService.removeItemDetails(c.get("db"), c.req.param("itemId"));
+    if (!row) {
+        return c.json({ error: "Not found" }, 404);
+    }
+    return c.json({ success: true });
+});
+// ---------- extension export ----------
+const productsBookingExtensionDef = {
+    name: "products-booking",
+    module: "bookings",
+};
+export const productsBookingExtension = {
+    extension: productsBookingExtensionDef,
+    routes: bookingProductExtensionRoutes,
+};

package/dist/catalog-policy-departures.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Catalog plane field policy for product → departures denormalization.
+ *
+ * These fields don't live on the `products` table — they're aggregated
+ * from `availability_slots` (filtered to `status = 'open'` and future
+ * `startsAt`) at index time and projected onto the product search
+ * document. See `docs/architecture/catalog-architecture.md` §5.4.
+ *
+ * Storefront product cards filter and display by departure surface:
+ *   - "departing in May" (filter: `departureMonths[]` includes "2026-05")
+ *   - "available this weekend" (filter: `departureDates[]` overlap)
+ *   - "available now" (filter: `hasUpcomingDeparture:true`)
+ *   - sort by next departure (`nextDepartureDate` asc)
+ *   - show capacity badge (`availableUnitsTotal`)
+ *
+ * Wire this policy into the products registry by composing with
+ * `productCatalogPolicy`:
+ *
+ *   const registry = createFieldPolicyRegistry([
+ *     ...productCatalogPolicy,
+ *     ...productDeparturesCatalogPolicy,
+ *   ])
+ *
+ * and wire `createProductDeparturesProjectionExtension` into
+ * `createProductDocumentBuilder` so the values land in the doc.
+ *
+ * Reindex semantics: every aggregation depends on `now()` — the same
+ * product reindexed an hour later will produce slightly different
+ * documents because the future window slides. Operators rely on the
+ * channel-push reconciler + scheduled refresh to keep these fields warm
+ * without storming the indexer on each tick. Per architecture §5.4,
+ * `reindex: "facet-affecting"` is the right tier — these fields drive
+ * facets but aren't on the merchandisable hot path.
+ *
+ * Out of scope here:
+ *   - Sold-out / cancelled / closed slots. The projection only counts
+ *     `status = 'open'` so storefront filters never surface unavailable
+ *     departures. A "show sold-out" toggle is a query-time concern.
+ *   - Per-option splits. Today's projection rolls up to the product;
+ *     per-option faceting is a follow-up if storefronts need it.
+ *   - Duration buckets (nights/days). Slots carry these but products
+ *     with mixed-duration slots can't be summarized in one number.
+ */
+import { type FieldPolicyInput } from "@voyant-travel/catalog/contract";
+declare const PRODUCT_DEPARTURES_FIELD_POLICY: FieldPolicyInput[];
+/**
+ * Resolved departures policy. Compose with `productCatalogPolicy` when
+ * building the products registry.
+ */
+export declare const productDeparturesCatalogPolicy: import("@voyant-travel/catalog").FieldPolicy[];
+export { PRODUCT_DEPARTURES_FIELD_POLICY };
+//# sourceMappingURL=catalog-policy-departures.d.ts.map

package/dist/catalog-policy-departures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-policy-departures.d.ts","sourceRoot":"","sources":["../src/catalog-policy-departures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAE1F,QAAA,MAAM,+BAA+B,EAAE,gBAAgB,EAyHtD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,8BAA8B,gDAAqD,CAAA;AAEhG,OAAO,EAAE,+BAA+B,EAAE,CAAA"}

package/dist/catalog-policy-departures.js

@@ -0,0 +1,169 @@
+/**
+ * Catalog plane field policy for product → departures denormalization.
+ *
+ * These fields don't live on the `products` table — they're aggregated
+ * from `availability_slots` (filtered to `status = 'open'` and future
+ * `startsAt`) at index time and projected onto the product search
+ * document. See `docs/architecture/catalog-architecture.md` §5.4.
+ *
+ * Storefront product cards filter and display by departure surface:
+ *   - "departing in May" (filter: `departureMonths[]` includes "2026-05")
+ *   - "available this weekend" (filter: `departureDates[]` overlap)
+ *   - "available now" (filter: `hasUpcomingDeparture:true`)
+ *   - sort by next departure (`nextDepartureDate` asc)
+ *   - show capacity badge (`availableUnitsTotal`)
+ *
+ * Wire this policy into the products registry by composing with
+ * `productCatalogPolicy`:
+ *
+ *   const registry = createFieldPolicyRegistry([
+ *     ...productCatalogPolicy,
+ *     ...productDeparturesCatalogPolicy,
+ *   ])
+ *
+ * and wire `createProductDeparturesProjectionExtension` into
+ * `createProductDocumentBuilder` so the values land in the doc.
+ *
+ * Reindex semantics: every aggregation depends on `now()` — the same
+ * product reindexed an hour later will produce slightly different
+ * documents because the future window slides. Operators rely on the
+ * channel-push reconciler + scheduled refresh to keep these fields warm
+ * without storming the indexer on each tick. Per architecture §5.4,
+ * `reindex: "facet-affecting"` is the right tier — these fields drive
+ * facets but aren't on the merchandisable hot path.
+ *
+ * Out of scope here:
+ *   - Sold-out / cancelled / closed slots. The projection only counts
+ *     `status = 'open'` so storefront filters never surface unavailable
+ *     departures. A "show sold-out" toggle is a query-time concern.
+ *   - Per-option splits. Today's projection rolls up to the product;
+ *     per-option faceting is a follow-up if storefronts need it.
+ *   - Duration buckets (nights/days). Slots carry these but products
+ *     with mixed-duration slots can't be summarized in one number.
+ */
+import { defineFieldPolicy } from "@voyant-travel/catalog/contract";
+const PRODUCT_DEPARTURES_FIELD_POLICY = [
+    // ── Earliest open future departure ──────────────────────────────────────
+    // `nextDepartureAt` is the timestamptz for storefront display metadata.
+    // `nextDepartureDate` is the slot's local calendar date and backs catalog
+    // sort by soonest available.
+    {
+        path: "nextDepartureAt",
+        class: "structural",
+        merge: "source-only",
+        drift: "low",
+        reindex: "facet-affecting",
+        snapshot: "on-book",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "sync",
+    },
+    {
+        path: "nextDepartureDate",
+        class: "structural",
+        merge: "source-only",
+        drift: "low",
+        reindex: "facet-affecting",
+        snapshot: "on-book",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "sync",
+    },
+    // ── Existence + count facets ─────────────────────────────────────────────
+    // `hasUpcomingDeparture` is the cheap "available now" filter. The count
+    // lets storefront sort by "lots of options available" without exposing
+    // the date list to the query layer.
+    {
+        path: "hasUpcomingDeparture",
+        class: "structural",
+        merge: "source-only",
+        drift: "low",
+        reindex: "facet-affecting",
+        snapshot: "on-book",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "sync",
+    },
+    {
+        path: "upcomingDepartureCount",
+        class: "structural",
+        merge: "source-only",
+        drift: "low",
+        reindex: "facet-affecting",
+        snapshot: "on-book",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "sync",
+    },
+    // ── Calendar-bucket facets ──────────────────────────────────────────────
+    // `departureDates[]` powers fine-grained "this weekend" / "next week"
+    // filters; capped at 180 days of distinct calendar dates so document
+    // size stays bounded for daily-slot products. `departureMonths[]` is
+    // the longer-tail facet — 24 months of "YYYY-MM" tokens covers an
+    // operator's typical forward-published inventory horizon.
+    {
+        path: "departureDates[]",
+        class: "structural",
+        merge: "source-only",
+        drift: "low",
+        reindex: "facet-affecting",
+        snapshot: "on-book",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "sync",
+    },
+    {
+        path: "departureMonths[]",
+        class: "structural",
+        merge: "source-only",
+        drift: "low",
+        reindex: "facet-affecting",
+        snapshot: "on-book",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "sync",
+    },
+    // ── Capacity ────────────────────────────────────────────────────────────
+    // Sum of `remaining_pax` across upcoming open slots. `null` when ANY
+    // counted slot is unlimited — unbounded capacity can't be summarized in
+    // a number, and emitting a partial sum would mislead the storefront
+    // ("3 seats left" when one slot is actually unlimited).
+    {
+        path: "availableUnitsTotal",
+        class: "structural",
+        merge: "source-only",
+        drift: "low",
+        reindex: "facet-affecting",
+        snapshot: "on-book",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "sync",
+    },
+];
+/**
+ * Resolved departures policy. Compose with `productCatalogPolicy` when
+ * building the products registry.
+ */
+export const productDeparturesCatalogPolicy = defineFieldPolicy(PRODUCT_DEPARTURES_FIELD_POLICY);
+export { PRODUCT_DEPARTURES_FIELD_POLICY };