@voyant-travel/distribution 0.109.8

package/dist/channel-push/reconciler.js

@@ -0,0 +1,179 @@
+/**
+ * Channel-push reconciler — self-healing catch-up for divergence.
+ *
+ * Eventually-consistent push works while the channel is reachable most
+ * of the time. After a long outage (or when an integration is first
+ * turned on for a channel that already has local state), the channel's
+ * view of our inventory diverges from ours. The reconciler closes that
+ * gap by re-reading current state from owned tables and recreating
+ * intent rows for divergent ones — same intent + worker pipeline, not
+ * a parallel push path.
+ *
+ * v1 cadences (per §13.2, tunable per channel):
+ *   - Booking-link reconciler: every 15 min
+ *   - Availability reconciler: hourly
+ *   - Content reconciler: nightly
+ *
+ * Templates schedule these via cron / the workflows runtime; the
+ * functions themselves are plain async so they're testable.
+ *
+ * Per docs/architecture/channel-push-architecture.md §13.
+ */
+import { and, asc, eq, inArray, sql } from "drizzle-orm";
+import { channelBookingLinks, channelInventoryAllotments, channelProductMappings, channels, } from "../schema.js";
+import { upsertAvailabilityIntent } from "./availability-push.js";
+import { processBookingPush } from "./booking-push.js";
+import { loadContentPushProducts, loadRecentlyUpdatedAvailabilityPushSlots, } from "./boundary-sql.js";
+import { canonicalHash, upsertContentIntent } from "./content-push.js";
+import { defaultLogger, getChannelPushDepsOrThrow } from "./types.js";
+/**
+ * Walk `channel_booking_links` where push_status != 'ok' and reissue
+ * via `processBookingPush`. The processor is idempotent on
+ * `idempotency_key`, so reissuing succeeded-then-edited links never
+ * doubles upstream.
+ *
+ * Per §13.1.
+ */
+export async function reconcileBookingLinks(options = {}, deps) {
+    const { db, logger = defaultLogger } = deps ?? getChannelPushDepsOrThrow();
+    const staleAfter = new Date(Date.now() - (options.staleAfterMs ?? 15 * 60 * 1000));
+    const limit = options.limit ?? 200;
+    const stale = (await db
+        .select({
+        bookingId: channelBookingLinks.bookingId,
+    })
+        .from(channelBookingLinks)
+        .where(and(
+    // agent-quality: raw-sql reviewed -- owner: distribution; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    sql `${channelBookingLinks.pushStatus} <> 'ok'`, 
+    // agent-quality: raw-sql reviewed -- owner: distribution; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    sql `(${channelBookingLinks.lastPushAt} IS NULL OR ${channelBookingLinks.lastPushAt} < ${staleAfter})`, options.channelId ? eq(channelBookingLinks.channelId, options.channelId) : sql `true`))
+        .orderBy(asc(channelBookingLinks.lastPushAt))
+        .limit(limit));
+    if (stale.length === 0)
+        return { scanned: 0, triggered: 0 };
+    const uniqueBookings = Array.from(new Set(stale.map((r) => r.bookingId)));
+    let triggered = 0;
+    for (const bookingId of uniqueBookings) {
+        try {
+            const result = await processBookingPush({ bookingId }, deps);
+            if (result.attempted > 0)
+                triggered += 1;
+        }
+        catch (err) {
+            logger.error?.(`reconcileBookingLinks: processBookingPush failed for ${bookingId}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return { scanned: stale.length, triggered };
+}
+/**
+ * Walk recently-updated slots and ensure an intent row exists per
+ * (channel, slot) where the channel holds an active allotment. The
+ * worker's existing UNIQUE constraint collapses duplicates, so this is
+ * safe to re-run.
+ *
+ * Per §13.1 (availability reconciler).
+ */
+export async function reconcileAvailability(options = {}, deps) {
+    const { db } = deps ?? getChannelPushDepsOrThrow();
+    const lookback = new Date(Date.now() - (options.lookbackMs ?? 60 * 60 * 1000));
+    const limit = options.limit ?? 500;
+    const slots = await loadRecentlyUpdatedAvailabilityPushSlots(db, {
+        updatedAfter: lookback,
+        limit,
+    });
+    if (slots.length === 0)
+        return { scanned: 0, triggered: 0 };
+    // For each slot, find channels with active allotments + matching
+    // product mappings, and upsert an intent row.
+    let triggered = 0;
+    const productIds = Array.from(new Set(slots.map((s) => s.productId)));
+    const allotments = (await db
+        .select({
+        allotment: channelInventoryAllotments,
+        mapping: channelProductMappings,
+    })
+        .from(channelInventoryAllotments)
+        .innerJoin(channelProductMappings, and(eq(channelProductMappings.channelId, channelInventoryAllotments.channelId), eq(channelProductMappings.productId, channelInventoryAllotments.productId)))
+        .innerJoin(channels, eq(channelInventoryAllotments.channelId, channels.id))
+        .where(and(inArray(channelInventoryAllotments.productId, productIds), eq(channelInventoryAllotments.active, true), eq(channelProductMappings.active, true), eq(channelProductMappings.pushAvailability, true), eq(channels.status, "active"), options.channelId ? eq(channelInventoryAllotments.channelId, options.channelId) : sql `true`)));
+    for (const slot of slots) {
+        for (const row of allotments) {
+            if (row.allotment.productId !== slot.productId)
+                continue;
+            // Allotment may be option-scoped; null option_id matches all.
+            if (row.allotment.optionId && row.allotment.optionId !== slot.optionId)
+                continue;
+            if (!row.mapping.sourceConnectionId)
+                continue;
+            await upsertAvailabilityIntent(db, {
+                channelId: row.mapping.channelId,
+                sourceConnectionId: row.mapping.sourceConnectionId,
+                slotId: slot.id,
+                productId: slot.productId,
+                optionId: slot.optionId ?? null,
+                startsAt: slot.startsAt,
+            });
+            triggered += 1;
+        }
+    }
+    return { scanned: slots.length, triggered };
+}
+/**
+ * Walk syndicated products, hash current content, and recreate an
+ * intent row for every (channel, product) where the upstream's
+ * `last_pushed_content_hash` doesn't match. Per §13.1 (content
+ * reconciler) — content drift converges nightly.
+ */
+export async function reconcileContent(options = {}, deps) {
+    const { db } = deps ?? getChannelPushDepsOrThrow();
+    const limit = options.limit ?? 200;
+    const mappings = (await db
+        .select({
+        mapping: channelProductMappings,
+    })
+        .from(channelProductMappings)
+        .innerJoin(channels, eq(channelProductMappings.channelId, channels.id))
+        .where(and(eq(channelProductMappings.active, true), eq(channelProductMappings.pushContent, true), eq(channels.status, "active"), options.channelId ? eq(channelProductMappings.channelId, options.channelId) : sql `true`))
+        .limit(limit));
+    const productIds = Array.from(new Set(mappings.map((row) => row.mapping.productId)));
+    const products = await loadContentPushProducts(db, productIds);
+    let triggered = 0;
+    for (const { mapping } of mappings) {
+        if (!mapping.sourceConnectionId)
+            continue;
+        const product = products.get(mapping.productId);
+        if (!product)
+            continue;
+        const minimalContent = {
+            id: product.id,
+            name: product.name,
+            description: product.description ?? null,
+        };
+        const currentHash = canonicalHash(minimalContent);
+        if (mapping.lastPushedContentHash === currentHash)
+            continue;
+        await upsertContentIntent(db, {
+            channelId: mapping.channelId,
+            sourceConnectionId: mapping.sourceConnectionId,
+            productId: mapping.productId,
+        });
+        triggered += 1;
+    }
+    return { scanned: mappings.length, triggered };
+}
+/**
+ * Convenience: run all three reconcilers with default cadences.
+ * Templates can call this from a single nightly cron, or schedule
+ * each independently for finer control.
+ */
+export async function runAllReconcilers(deps) {
+    const [bookingsResult, availability, content] = await Promise.all([
+        reconcileBookingLinks({}, deps),
+        reconcileAvailability({}, deps),
+        reconcileContent({}, deps),
+    ]);
+    return { bookings: bookingsResult, availability, content };
+}

package/dist/channel-push/subscriber.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Channel-push EventBus subscribers.
+ *
+ * The `booking.confirmed` subscriber writes durable intent rows to
+ * `channel_booking_links` and returns immediately — per §4.5 the
+ * subscriber MUST NOT do HTTP work because the EventBus is in-process
+ * and sequential. The intent rows are drained by `processBookingPush`
+ * (called inline in v1, or by the durable workflow in production).
+ *
+ * Per docs/architecture/channel-push-architecture.md §4.1.
+ */
+import type { Subscriber } from "@voyant-travel/core";
+import { type ChannelPushDeps } from "./types.js";
+export interface ChannelPushSubscribersOptions {
+    /**
+     * When `true` (default), the subscriber drains intent rows inline
+     * after writing them. Useful for dev / single-process templates.
+     * Production deployments with the workflow runtime wired set this
+     * to `false` and rely on `channel.booking.push` to drain.
+     */
+    drainInline?: boolean;
+    /**
+     * Optional explicit deps. Falls back to `getChannelPushDeps()`.
+     * Tests pass deps directly so they don't have to wire the global.
+     */
+    deps?: ChannelPushDeps;
+}
+/**
+ * Construct the channel-push subscriber bundle. Templates pass these to
+ * `registerPlugins({ subscribers })` or attach them to an EventBus
+ * directly via `eventBus.subscribe`.
+ */
+export declare function createChannelPushSubscribers(options?: ChannelPushSubscribersOptions): Subscriber[];
+/**
+ * Trigger the booking-push pipeline for an arbitrary booking id —
+ * useful for the operator dashboard's "retry sync" button and for the
+ * reconciler (Phase G).
+ */
+export declare function triggerBookingPushForBooking(bookingId: string): Promise<void>;
+//# sourceMappingURL=subscriber.d.ts.map

package/dist/channel-push/subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber.d.ts","sourceRoot":"","sources":["../../src/channel-push/subscriber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAiB,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAiBpE,OAAO,EACL,KAAK,eAAe,EAIrB,MAAM,YAAY,CAAA;AAwEnB,MAAM,WAAW,6BAA6B;IAC5C;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAA;CACvB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,GAAE,6BAAkC,GAC1C,UAAU,EAAE,CAwHd;AAED;;;;GAIG;AACH,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMnF"}

package/dist/channel-push/subscriber.js

@@ -0,0 +1,199 @@
+/**
+ * Channel-push EventBus subscribers.
+ *
+ * The `booking.confirmed` subscriber writes durable intent rows to
+ * `channel_booking_links` and returns immediately — per §4.5 the
+ * subscriber MUST NOT do HTTP work because the EventBus is in-process
+ * and sequential. The intent rows are drained by `processBookingPush`
+ * (called inline in v1, or by the durable workflow in production).
+ *
+ * Per docs/architecture/channel-push-architecture.md §4.1.
+ */
+import { processAvailabilityPushIntents, resolveAllotmentTargetsForSlot, upsertAvailabilityIntent, } from "./availability-push.js";
+import { processBookingPush, resolveBookingPushTargets, upsertPendingBookingLinks, } from "./booking-push.js";
+import { processContentPushIntents, resolveContentPushTargets, upsertContentIntent, } from "./content-push.js";
+import { defaultLogger, getChannelPushDeps, getChannelPushDepsOrThrow, } from "./types.js";
+function coerceBookingConfirmed(envelope) {
+    const data = envelope.data;
+    if (data == null || typeof data !== "object")
+        return null;
+    const maybe = data;
+    if (typeof maybe.bookingId !== "string")
+        return null;
+    return {
+        bookingId: maybe.bookingId,
+        ...(typeof maybe.bookingNumber === "string" ? { bookingNumber: maybe.bookingNumber } : {}),
+        ...(typeof maybe.actorId === "string" || maybe.actorId === null
+            ? { actorId: maybe.actorId }
+            : {}),
+    };
+}
+function coerceSlotChanged(envelope) {
+    const data = envelope.data;
+    if (data == null || typeof data !== "object")
+        return null;
+    const maybe = data;
+    if (typeof maybe.slotId !== "string" || typeof maybe.productId !== "string")
+        return null;
+    if (typeof maybe.optionId !== "string" && maybe.optionId !== null)
+        return null;
+    if (!(maybe.startsAt instanceof Date) && typeof maybe.startsAt !== "string")
+        return null;
+    if (typeof maybe.remainingPax !== "number" && maybe.remainingPax !== null)
+        return null;
+    if (typeof maybe.unlimited !== "boolean" || typeof maybe.source !== "string")
+        return null;
+    return {
+        slotId: maybe.slotId,
+        productId: maybe.productId,
+        optionId: maybe.optionId,
+        startsAt: maybe.startsAt,
+        remainingPax: maybe.remainingPax,
+        unlimited: maybe.unlimited,
+        source: maybe.source,
+    };
+}
+function coerceContentChanged(envelope) {
+    const data = envelope.data;
+    if (data == null || typeof data !== "object")
+        return null;
+    const maybe = data;
+    if (typeof maybe.id !== "string")
+        return null;
+    return {
+        id: maybe.id,
+        ...(typeof maybe.axis === "string" ? { axis: maybe.axis } : {}),
+    };
+}
+/**
+ * Construct the channel-push subscriber bundle. Templates pass these to
+ * `registerPlugins({ subscribers })` or attach them to an EventBus
+ * directly via `eventBus.subscribe`.
+ */
+export function createChannelPushSubscribers(options = {}) {
+    const drainInline = options.drainInline ?? true;
+    const handler = async (envelope) => {
+        const payload = coerceBookingConfirmed(envelope);
+        if (!payload)
+            return;
+        const deps = options.deps ?? getChannelPushDeps();
+        if (!deps) {
+            // Templates haven't wired channel-push — silent no-op so the rest
+            // of the booking flow isn't impacted by missing wiring.
+            return;
+        }
+        const logger = deps.logger ?? defaultLogger;
+        try {
+            const targets = await resolveBookingPushTargets(deps.db, payload.bookingId);
+            if (targets.length === 0)
+                return;
+            await upsertPendingBookingLinks(deps.db, payload.bookingId, targets);
+            if (drainInline) {
+                // Inline drain — simple deployments without the workflow runtime
+                // wired (dev templates, demo mode). Production uses the workflow
+                // and skips this branch.
+                await processBookingPush({ bookingId: payload.bookingId }, deps);
+            }
+        }
+        catch (err) {
+            logger.error("[channel-push] booking.confirmed subscriber failed", {
+                bookingId: payload.bookingId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    };
+    const slotHandler = async (envelope) => {
+        const payload = coerceSlotChanged(envelope);
+        if (!payload)
+            return;
+        const deps = options.deps ?? getChannelPushDeps();
+        if (!deps)
+            return;
+        const logger = deps.logger ?? defaultLogger;
+        try {
+            const targets = await resolveAllotmentTargetsForSlot(deps.db, {
+                slotId: payload.slotId,
+                productId: payload.productId,
+                optionId: payload.optionId,
+            });
+            if (targets.length === 0)
+                return;
+            const startsAt = payload.startsAt instanceof Date ? payload.startsAt : new Date(payload.startsAt);
+            // One intent per (channel, slot) pair — supersession collapses
+            // concurrent events.
+            for (const target of targets) {
+                await upsertAvailabilityIntent(deps.db, {
+                    channelId: target.channelId,
+                    sourceConnectionId: target.sourceConnectionId,
+                    slotId: payload.slotId,
+                    productId: payload.productId,
+                    optionId: payload.optionId,
+                    startsAt,
+                });
+            }
+            if (drainInline) {
+                // Drain only this channel's intents to keep latency bounded.
+                // (v1 dev behavior; production runs the scheduled workflow.)
+                for (const target of targets) {
+                    await processAvailabilityPushIntents({ channelId: target.channelId, limit: 50 }, deps);
+                }
+            }
+        }
+        catch (err) {
+            logger.error("[channel-push] availability.slot.changed subscriber failed", {
+                slotId: payload.slotId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    };
+    const contentHandler = async (envelope) => {
+        const payload = coerceContentChanged(envelope);
+        if (!payload)
+            return;
+        const deps = options.deps ?? getChannelPushDeps();
+        if (!deps)
+            return;
+        const logger = deps.logger ?? defaultLogger;
+        try {
+            const targets = await resolveContentPushTargets(deps.db, payload.id);
+            if (targets.length === 0)
+                return;
+            for (const target of targets) {
+                await upsertContentIntent(deps.db, {
+                    channelId: target.channelId,
+                    sourceConnectionId: target.sourceConnectionId,
+                    productId: payload.id,
+                });
+            }
+            if (drainInline) {
+                for (const target of targets) {
+                    await processContentPushIntents({ channelId: target.channelId, limit: 50 }, deps);
+                }
+            }
+        }
+        catch (err) {
+            logger.error("[channel-push] product.content.changed subscriber failed", {
+                productId: payload.id,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    };
+    return [
+        { event: "booking.confirmed", handler },
+        { event: "availability.slot.changed", handler: slotHandler },
+        { event: "product.content.changed", handler: contentHandler },
+    ];
+}
+/**
+ * Trigger the booking-push pipeline for an arbitrary booking id —
+ * useful for the operator dashboard's "retry sync" button and for the
+ * reconciler (Phase G).
+ */
+export async function triggerBookingPushForBooking(bookingId) {
+    const deps = getChannelPushDepsOrThrow();
+    const targets = await resolveBookingPushTargets(deps.db, bookingId);
+    if (targets.length === 0)
+        return;
+    await upsertPendingBookingLinks(deps.db, bookingId, targets);
+    await processBookingPush({ bookingId }, deps);
+}

package/dist/channel-push/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared types for the channel-push pipeline.
+ *
+ * Per docs/architecture/channel-push-architecture.md §4-§6.
+ */
+import type { SourceAdapterRegistry } from "@voyant-travel/catalog/booking-engine";
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+/**
+ * Process-local dependencies the channel-push workers and subscribers
+ * need. Templates wire this once at startup via `setChannelPushDeps`;
+ * callers retrieve via `getChannelPushDeps`.
+ *
+ * The runtime indirection lets workflows (which can't take closures in
+ * their durable input) and EventBus subscribers (which run in the
+ * emitter's process) share the same wiring without each consumer
+ * re-resolving services. Per §4.5 — subscribers stay write-only and
+ * delegate HTTP work to the workflow, which reaches into these deps.
+ */
+export interface ChannelPushDeps {
+    db: AnyDrizzleDb;
+    registry: SourceAdapterRegistry;
+    /**
+     * Optional logger. Defaults to a console fallback. Subscribers and
+     * workers log to this when they swallow errors per the EventBus
+     * fire-and-forget contract.
+     */
+    logger?: ChannelPushLogger;
+}
+export interface ChannelPushLogger {
+    info?: (message: string, meta?: Record<string, unknown>) => void;
+    warn?: (message: string, meta?: Record<string, unknown>) => void;
+    error: (message: string, meta?: Record<string, unknown>) => void;
+}
+/** Wire the channel-push pipeline at process start. Idempotent. */
+export declare function setChannelPushDeps(deps: ChannelPushDeps): void;
+/** Retrieve the wired deps, throwing if templates haven't wired them. */
+export declare function getChannelPushDepsOrThrow(): ChannelPushDeps;
+/** Retrieve the wired deps, returning undefined when none are wired. */
+export declare function getChannelPushDeps(): ChannelPushDeps | undefined;
+/** Reset (test helper). */
+export declare function clearChannelPushDeps(): void;
+export declare const defaultLogger: ChannelPushLogger;
+//# sourceMappingURL=types.d.ts.map

package/dist/channel-push/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/channel-push/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAA;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,YAAY,CAAA;IAChB,QAAQ,EAAE,qBAAqB,CAAA;IAC/B;;;;OAIG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAA;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IAChE,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IAChE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;CACjE;AAUD,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAE9D;AAED,yEAAyE;AACzE,wBAAgB,yBAAyB,IAAI,eAAe,CAQ3D;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,IAAI,eAAe,GAAG,SAAS,CAEhE;AAED,2BAA2B;AAC3B,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,eAAO,MAAM,aAAa,EAAE,iBAI3B,CAAA"}

package/dist/channel-push/types.js

@@ -0,0 +1,32 @@
+/**
+ * Shared types for the channel-push pipeline.
+ *
+ * Per docs/architecture/channel-push-architecture.md §4-§6.
+ */
+const DEPS_KEY = Symbol.for("voyant.distribution.channel-push.deps");
+const globalRef = globalThis;
+/** Wire the channel-push pipeline at process start. Idempotent. */
+export function setChannelPushDeps(deps) {
+    globalRef[DEPS_KEY] = deps;
+}
+/** Retrieve the wired deps, throwing if templates haven't wired them. */
+export function getChannelPushDepsOrThrow() {
+    const deps = globalRef[DEPS_KEY];
+    if (!deps) {
+        throw new Error("channel-push deps not wired — call setChannelPushDeps({ db, registry }) at process start");
+    }
+    return deps;
+}
+/** Retrieve the wired deps, returning undefined when none are wired. */
+export function getChannelPushDeps() {
+    return globalRef[DEPS_KEY];
+}
+/** Reset (test helper). */
+export function clearChannelPushDeps() {
+    delete globalRef[DEPS_KEY];
+}
+export const defaultLogger = {
+    info: (message, meta) => console.log(`[channel-push] ${message}`, meta ?? ""),
+    warn: (message, meta) => console.warn(`[channel-push] ${message}`, meta ?? ""),
+    error: (message, meta) => console.error(`[channel-push] ${message}`, meta ?? ""),
+};

package/dist/channel-push/workflows.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Durable channel-push workflows.
+ *
+ * Wraps the inline-callable processors (`processBookingPush`,
+ * `processAvailabilityPushIntents`, `processContentPushIntents`) in
+ * `@voyant-travel/workflows` definitions so retries, sleeps, and resumption
+ * survive worker restarts. Importing this module registers the
+ * workflows in the global registry — Voyant Cloud orchestrator picks
+ * them up automatically.
+ *
+ * The workflow bodies look up `ChannelPushDeps` from the process-local
+ * holder set via `setChannelPushDeps`. Hosts wire deps at bootstrap;
+ * the orchestrator's Node container reads from the same global since
+ * it runs in the same isolate that loaded the user bundle.
+ *
+ * Dev / single-process deployments (e.g. the operator starter's
+ * inline drain) don't need to register these — the subscriber calls the
+ * processors directly. Production deployments with the Voyant Cloud
+ * orchestrator wired import this module to opt into durability.
+ *
+ * Per docs/architecture/channel-push-architecture.md §4.2 + §12.
+ */
+import { type ProcessAvailabilityPushInput, type ProcessAvailabilityPushResult } from "./availability-push.js";
+import { type ProcessBookingPushInput, type ProcessBookingPushResult } from "./booking-push.js";
+import { type ProcessContentPushInput, type ProcessContentPushResult } from "./content-push.js";
+/**
+ * Per-booking saga workflow with compensation support.
+ *
+ * Concurrency is keyed by `bookingId` so two confirms of the same
+ * booking serialize (which can't actually happen given the booking
+ * state machine, but the perKey lock is cheap insurance). Retries on
+ * exponential backoff up to 5 attempts; the per-link compensation pass
+ * inside `processBookingPush` handles strict-atomic policy when
+ * `channel_contracts.policy.compensation = "strict-atomic"`.
+ *
+ * Per §4.2 + §12.1.
+ */
+export declare const channelBookingPushWorkflow: import("@voyant-travel/workflows").WorkflowDefinition<ProcessBookingPushInput, ProcessBookingPushResult>;
+/**
+ * Scheduled batch worker for availability push. Runs every 30 seconds
+ * (tunable per channel via policy in a future iteration); each tick
+ * drains up to 100 pending intents, capped at one concurrent run per
+ * channel. Idempotency is upstream-side via `(slot_id, remaining_pax)`.
+ *
+ * Per §5.3 + §12.2.
+ */
+export declare const channelAvailabilityPushWorkflow: import("@voyant-travel/workflows").WorkflowDefinition<ProcessAvailabilityPushInput, ProcessAvailabilityPushResult>;
+/**
+ * Scheduled batch worker for content push. Longer cadence (5m) since
+ * content drift is rarely time-critical; idempotency via the upstream's
+ * acknowledged-hash skip in `processContentPushIntents`.
+ *
+ * Per §6 + §12.3.
+ */
+export declare const channelContentPushWorkflow: import("@voyant-travel/workflows").WorkflowDefinition<ProcessContentPushInput, ProcessContentPushResult>;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/channel-push/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/channel-push/workflows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAEnC,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAE9B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAE9B,MAAM,mBAAmB,CAAA;AAE1B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,0GAiBrC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,oHAkB1C,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,0GAkBrC,CAAA"}

package/dist/channel-push/workflows.js

@@ -0,0 +1,100 @@
+/**
+ * Durable channel-push workflows.
+ *
+ * Wraps the inline-callable processors (`processBookingPush`,
+ * `processAvailabilityPushIntents`, `processContentPushIntents`) in
+ * `@voyant-travel/workflows` definitions so retries, sleeps, and resumption
+ * survive worker restarts. Importing this module registers the
+ * workflows in the global registry — Voyant Cloud orchestrator picks
+ * them up automatically.
+ *
+ * The workflow bodies look up `ChannelPushDeps` from the process-local
+ * holder set via `setChannelPushDeps`. Hosts wire deps at bootstrap;
+ * the orchestrator's Node container reads from the same global since
+ * it runs in the same isolate that loaded the user bundle.
+ *
+ * Dev / single-process deployments (e.g. the operator starter's
+ * inline drain) don't need to register these — the subscriber calls the
+ * processors directly. Production deployments with the Voyant Cloud
+ * orchestrator wired import this module to opt into durability.
+ *
+ * Per docs/architecture/channel-push-architecture.md §4.2 + §12.
+ */
+import { workflow } from "@voyant-travel/workflows";
+import { CHANNEL_AVAILABILITY_PUSH_WORKFLOW_ID, processAvailabilityPushIntents, } from "./availability-push.js";
+import { CHANNEL_BOOKING_PUSH_WORKFLOW_ID, processBookingPush, } from "./booking-push.js";
+import { CHANNEL_CONTENT_PUSH_WORKFLOW_ID, processContentPushIntents, } from "./content-push.js";
+/**
+ * Per-booking saga workflow with compensation support.
+ *
+ * Concurrency is keyed by `bookingId` so two confirms of the same
+ * booking serialize (which can't actually happen given the booking
+ * state machine, but the perKey lock is cheap insurance). Retries on
+ * exponential backoff up to 5 attempts; the per-link compensation pass
+ * inside `processBookingPush` handles strict-atomic policy when
+ * `channel_contracts.policy.compensation = "strict-atomic"`.
+ *
+ * Per §4.2 + §12.1.
+ */
+export const channelBookingPushWorkflow = workflow({
+    id: CHANNEL_BOOKING_PUSH_WORKFLOW_ID,
+    description: "Drain pending channel_booking_links and push to upstream channels",
+    retry: { backoff: "exponential", max: 5, initial: "5s", maxDelay: "5m" },
+    timeout: "1h",
+    concurrency: {
+        key: (input) => input.bookingId,
+        limit: 1,
+        strategy: "queue",
+    },
+    tags: ["channel-push", "booking"],
+    async run(input, ctx) {
+        return await ctx.step("process-booking-push", () => processBookingPush(input));
+    },
+});
+/**
+ * Scheduled batch worker for availability push. Runs every 30 seconds
+ * (tunable per channel via policy in a future iteration); each tick
+ * drains up to 100 pending intents, capped at one concurrent run per
+ * channel. Idempotency is upstream-side via `(slot_id, remaining_pax)`.
+ *
+ * Per §5.3 + §12.2.
+ */
+export const channelAvailabilityPushWorkflow = workflow({
+    id: CHANNEL_AVAILABILITY_PUSH_WORKFLOW_ID,
+    description: "Drain channel_availability_push_intents per channel",
+    schedule: { every: "30s" },
+    retry: { backoff: "exponential", max: 3, initial: "10s" },
+    timeout: "5m",
+    concurrency: {
+        key: (input) => input.channelId ?? "all",
+        limit: 1,
+        strategy: "queue",
+    },
+    tags: ["channel-push", "availability"],
+    async run(input, ctx) {
+        return await ctx.step("process-availability-push", () => processAvailabilityPushIntents(input));
+    },
+});
+/**
+ * Scheduled batch worker for content push. Longer cadence (5m) since
+ * content drift is rarely time-critical; idempotency via the upstream's
+ * acknowledged-hash skip in `processContentPushIntents`.
+ *
+ * Per §6 + §12.3.
+ */
+export const channelContentPushWorkflow = workflow({
+    id: CHANNEL_CONTENT_PUSH_WORKFLOW_ID,
+    description: "Drain channel_content_push_intents per channel",
+    schedule: { every: "5m" },
+    retry: { backoff: "exponential", max: 3, initial: "30s" },
+    timeout: "5m",
+    concurrency: {
+        key: (input) => input.channelId ?? "all",
+        limit: 1,
+        strategy: "queue",
+    },
+    tags: ["channel-push", "content"],
+    async run(input, ctx) {
+        return await ctx.step("process-content-push", () => processContentPushIntents(input));
+    },
+});