@voyant-travel/distribution 0.109.8

package/dist/channel-push/boundary-sql.js

@@ -0,0 +1,75 @@
+import { sql } from "drizzle-orm";
+async function executeBoundaryRows(db, query) {
+    // biome-ignore lint/suspicious/noExplicitAny: #1141 keeps cross-package SQL boundary reads driver-agnostic.
+    const result = await db.execute(query);
+    return (Array.isArray(result) ? result : (result?.rows ?? []));
+}
+function sqlList(values) {
+    // agent-quality: raw-sql reviewed -- owner: distribution; callers pass only parameter-bound scalar ids into the joined SQL fragment.
+    return sql.join(values.map((value) => sql `${value}`), sql `, `);
+}
+function toDate(value) {
+    return value instanceof Date ? value : new Date(value);
+}
+function toNumber(value) {
+    if (value === null)
+        return null;
+    return typeof value === "number" ? value : Number(value);
+}
+function mapAvailabilitySlot(row) {
+    return {
+        id: row.id,
+        productId: row.product_id,
+        optionId: row.option_id,
+        startsAt: toDate(row.starts_at),
+        unlimited: row.unlimited,
+        remainingPax: toNumber(row.remaining_pax),
+        updatedAt: toDate(row.updated_at),
+    };
+}
+export async function loadAvailabilityPushSlot(db, slotId) {
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: distribution; Availability is a read-only push source and slot id is parameter-bound.
+    sql `
+      SELECT id, product_id, option_id, starts_at, unlimited, remaining_pax, updated_at
+      FROM availability_slots
+      WHERE id = ${slotId}
+      LIMIT 1
+    `);
+    return rows[0] ? mapAvailabilitySlot(rows[0]) : null;
+}
+export async function loadRecentlyUpdatedAvailabilityPushSlots(db, input) {
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: distribution; Availability slots are read-only reconciler sources with parameter-bound cursor and limit.
+    sql `
+      SELECT id, product_id, option_id, starts_at, unlimited, remaining_pax, updated_at
+      FROM availability_slots
+      WHERE updated_at > ${input.updatedAfter}
+      ORDER BY updated_at ASC
+      LIMIT ${input.limit}
+    `);
+    return rows.map(mapAvailabilitySlot);
+}
+export async function loadContentPushProduct(db, productId) {
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: distribution; Product is a read-only content-push source and product id is parameter-bound.
+    sql `
+      SELECT id, name, description
+      FROM products
+      WHERE id = ${productId}
+      LIMIT 1
+    `);
+    return rows[0] ?? null;
+}
+export async function loadContentPushProducts(db, productIds) {
+    if (productIds.length === 0)
+        return new Map();
+    const rows = await executeBoundaryRows(db, 
+    // agent-quality: raw-sql reviewed -- owner: distribution; Product is a read-only content-push source and product ids are parameter-bound.
+    sql `
+      SELECT id, name, description
+      FROM products
+      WHERE id IN (${sqlList(productIds)})
+    `);
+    return new Map(rows.map((row) => [row.id, row]));
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Content-push pipeline.
+ *
+ * Triggered by `product.content.changed`. The subscriber upserts a
+ * `channel_content_push_intents` row per (channel, product); concurrent
+ * edits collapse to one row. The processor drains intents, hashes the
+ * current content, and skips when the hash equals
+ * `channel_product_mappings.last_pushed_content_hash` — channel-side
+ * idempotency per §6.1.
+ *
+ * Per docs/architecture/channel-push-architecture.md §6 + §12.3.
+ */
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { channelProductMappings, channels } from "../schema.js";
+import { type ChannelPushDeps } from "./types.js";
+/** Stable string identifier for the content-push workflow. */
+export declare const CHANNEL_CONTENT_PUSH_WORKFLOW_ID: "channel.content.push";
+/**
+ * Resolve the channels that want a content push for this product.
+ * Per §7.4 — content push uses `channel_product_mappings` (content is
+ * product-shaped, not slot-shaped).
+ */
+export declare function resolveContentPushTargets(db: AnyDrizzleDb, productId: string): Promise<Array<{
+    channelId: string;
+    sourceConnectionId: string;
+    mapping: typeof channelProductMappings.$inferSelect;
+    channel: typeof channels.$inferSelect;
+}>>;
+export declare function upsertContentIntent(db: AnyDrizzleDb, input: {
+    channelId: string;
+    sourceConnectionId: string;
+    productId: string;
+}): Promise<void>;
+export interface ProcessContentPushInput {
+    channelId?: string;
+    limit?: number;
+}
+export interface ProcessContentPushResult {
+    attempted: number;
+    succeeded: number;
+    failed: number;
+    skipped: number;
+}
+/**
+ * Drain pending content intents. Hashes current product content and
+ * skips when the hash matches the upstream's last-known hash.
+ *
+ * v1 ships a minimal `content` payload (product row fields). Real
+ * verticals supply richer payloads via a future content provider hook.
+ *
+ * Per §6 + §12.3.
+ */
+export declare function processContentPushIntents(input?: ProcessContentPushInput, deps?: ChannelPushDeps): Promise<ProcessContentPushResult>;
+/**
+ * Stable canonical-JSON hash. Mirrors the body-fingerprint behavior
+ * of `webhook-deliveries.ts` — purely a "is this the same content as
+ * before?" fingerprint, not a cryptographic hash.
+ */
+export declare function canonicalHash(value: unknown): string;
+//# sourceMappingURL=content-push.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content-push.d.ts","sourceRoot":"","sources":["../../src/channel-push/content-push.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,OAAO,EAA6B,sBAAsB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAI1F,OAAO,EAAE,KAAK,eAAe,EAA4C,MAAM,YAAY,CAAA;AAE3F,8DAA8D;AAC9D,eAAO,MAAM,gCAAgC,EAAG,sBAA+B,CAAA;AAE/E;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CACR,KAAK,CAAC;IACJ,SAAS,EAAE,MAAM,CAAA;IACjB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,OAAO,EAAE,OAAO,sBAAsB,CAAC,YAAY,CAAA;IACnD,OAAO,EAAE,OAAO,QAAQ,CAAC,YAAY,CAAA;CACtC,CAAC,CACH,CA4BA;AAED,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC1E,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,KAAK,GAAE,uBAA4B,EACnC,IAAI,CAAC,EAAE,eAAe,GACrB,OAAO,CAAC,wBAAwB,CAAC,CAmKnC;AAkCD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAepD"}

package/dist/channel-push/content-push.js

@@ -0,0 +1,252 @@
+/**
+ * Content-push pipeline.
+ *
+ * Triggered by `product.content.changed`. The subscriber upserts a
+ * `channel_content_push_intents` row per (channel, product); concurrent
+ * edits collapse to one row. The processor drains intents, hashes the
+ * current content, and skips when the hash equals
+ * `channel_product_mappings.last_pushed_content_hash` — channel-side
+ * idempotency per §6.1.
+ *
+ * Per docs/architecture/channel-push-architecture.md §6 + §12.3.
+ */
+import { AdapterRateLimitedError, } from "@voyant-travel/catalog";
+import { newId } from "@voyant-travel/db/lib/typeid";
+import { and, asc, eq, sql } from "drizzle-orm";
+import { acquireToken, channelScopeKey, drainBucket } from "../rate-limit.js";
+import { channelContentPushIntents, channelProductMappings, channels } from "../schema.js";
+import { prepareOutboundEnvelope } from "../webhook-deliveries.js";
+import { loadContentPushProduct } from "./boundary-sql.js";
+import { defaultLogger, getChannelPushDepsOrThrow } from "./types.js";
+/** Stable string identifier for the content-push workflow. */
+export const CHANNEL_CONTENT_PUSH_WORKFLOW_ID = "channel.content.push";
+/**
+ * Resolve the channels that want a content push for this product.
+ * Per §7.4 — content push uses `channel_product_mappings` (content is
+ * product-shaped, not slot-shaped).
+ */
+export async function resolveContentPushTargets(db, productId) {
+    const rows = (await db
+        .select({
+        mapping: channelProductMappings,
+        channel: channels,
+    })
+        .from(channelProductMappings)
+        .innerJoin(channels, eq(channelProductMappings.channelId, channels.id))
+        .where(and(eq(channelProductMappings.productId, productId), eq(channelProductMappings.active, true), eq(channelProductMappings.pushContent, true), eq(channels.status, "active"))));
+    return rows
+        .filter((row) => row.mapping.sourceConnectionId)
+        .map((row) => ({
+        channelId: row.channel.id,
+        sourceConnectionId: row.mapping.sourceConnectionId,
+        mapping: row.mapping,
+        channel: row.channel,
+    }));
+}
+export async function upsertContentIntent(db, input) {
+    await db
+        .insert(channelContentPushIntents)
+        .values({
+        id: newId("channel_content_push_intents"),
+        channelId: input.channelId,
+        sourceConnectionId: input.sourceConnectionId,
+        productId: input.productId,
+    })
+        .onConflictDoUpdate({
+        target: [channelContentPushIntents.channelId, channelContentPushIntents.productId],
+        set: {
+            requestedAt: new Date(),
+            updatedAt: new Date(),
+            attempts: 0,
+            lastError: null,
+        },
+    });
+}
+/**
+ * Drain pending content intents. Hashes current product content and
+ * skips when the hash matches the upstream's last-known hash.
+ *
+ * v1 ships a minimal `content` payload (product row fields). Real
+ * verticals supply richer payloads via a future content provider hook.
+ *
+ * Per §6 + §12.3.
+ */
+export async function processContentPushIntents(input = {}, deps) {
+    const { db, registry, logger = defaultLogger } = deps ?? getChannelPushDepsOrThrow();
+    const limit = input.limit ?? 100;
+    const intents = (await db
+        .select({
+        intent: channelContentPushIntents,
+        channel: channels,
+    })
+        .from(channelContentPushIntents)
+        .innerJoin(channels, eq(channelContentPushIntents.channelId, channels.id))
+        .where(and(input.channelId ? eq(channelContentPushIntents.channelId, input.channelId) : sql `true`, eq(channels.status, "active")))
+        .orderBy(asc(channelContentPushIntents.requestedAt))
+        .limit(limit));
+    let succeeded = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const { intent, channel } of intents) {
+        const product = await loadContentPushProduct(db, intent.productId);
+        if (!product) {
+            await db.delete(channelContentPushIntents).where(eq(channelContentPushIntents.id, intent.id));
+            skipped += 1;
+            continue;
+        }
+        const adapter = registry.resolveByConnection(intent.sourceConnectionId);
+        if (!adapter?.capabilities.supportsContentPush || !adapter.pushContent) {
+            await stampIntentError(db, intent.id, intent.attempts + 1, adapter ? "adapter_unsupported" : "no_adapter_registered");
+            failed += 1;
+            continue;
+        }
+        const [mapping] = (await db
+            .select()
+            .from(channelProductMappings)
+            .where(and(eq(channelProductMappings.channelId, channel.id), eq(channelProductMappings.productId, intent.productId)))
+            .limit(1));
+        if (!mapping) {
+            await stampIntentError(db, intent.id, intent.attempts + 1, "no_mapping");
+            failed += 1;
+            continue;
+        }
+        // Build the content payload + hash. v1 = product row fields. Future
+        // iterations call a per-vertical content provider so the payload
+        // mirrors `GetContentResult` (itinerary, media, options, …).
+        const content = buildMinimalContent(product);
+        const contentHash = canonicalHash(content);
+        // Idempotency: skip when the upstream's last-known hash equals
+        // the current hash. Per §6.1.
+        if (mapping.lastPushedContentHash === contentHash) {
+            await db.delete(channelContentPushIntents).where(eq(channelContentPushIntents.id, intent.id));
+            skipped += 1;
+            continue;
+        }
+        const rlConfig = rateLimitConfigForChannel(channel);
+        if (rlConfig) {
+            const acq = await acquireToken(db, channelScopeKey(channel.id, intent.sourceConnectionId), rlConfig, "content");
+            if (!acq.acquired) {
+                await stampIntentError(db, intent.id, intent.attempts + 1, "rate_limited");
+                failed += 1;
+                continue;
+            }
+        }
+        const request = {
+            channelId: channel.id,
+            externalProductId: mapping.externalProductId ?? "",
+            productId: intent.productId,
+            contentHash,
+            content,
+            contentSchemaVersion: "products/v1",
+        };
+        const adapterCtx = {
+            connection_id: intent.sourceConnectionId,
+        };
+        const envelope = await prepareOutboundEnvelope(db, {
+            sourceModule: "distribution",
+            sourceEvent: "channel.content.push",
+            sourceEntityModule: "products",
+            sourceEntityId: intent.productId,
+            targetUrl: `adapter:${adapter.kind}`,
+            targetKind: `channel:${adapter.kind}`,
+            targetRef: channel.id,
+            requestMethod: "POST",
+            requestBody: request,
+            attemptNumber: intent.attempts + 1,
+        });
+        try {
+            const result = await adapter.pushContent(adapterCtx, request);
+            await envelope.complete({ responseStatus: 200, responseBody: result });
+            // Persist the acknowledged hash so subsequent pushes skip if
+            // content hasn't changed. Per §6.1.
+            await db
+                .update(channelProductMappings)
+                .set({
+                lastPushedContentHash: result.acknowledgedHash ?? contentHash,
+                lastPushedContentAt: new Date(),
+                updatedAt: new Date(),
+            })
+                .where(eq(channelProductMappings.id, mapping.id));
+            await db.delete(channelContentPushIntents).where(eq(channelContentPushIntents.id, intent.id));
+            succeeded += 1;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const isRateLimited = err instanceof AdapterRateLimitedError;
+            if (isRateLimited) {
+                await drainBucket(db, channelScopeKey(channel.id, intent.sourceConnectionId), err.retryAfterMs);
+            }
+            await envelope.complete({
+                errorClass: isRateLimited ? "rate_limited" : "adapter_error",
+                errorMessage: message,
+            });
+            await stampIntentError(db, intent.id, intent.attempts + 1, message);
+            failed += 1;
+            logger.error?.(`pushContent failed for product ${intent.productId} channel ${channel.id}`, {
+                error: message,
+            });
+        }
+    }
+    return {
+        attempted: intents.length,
+        succeeded,
+        failed,
+        skipped,
+    };
+}
+async function stampIntentError(db, id, attempts, message) {
+    await db
+        .update(channelContentPushIntents)
+        .set({ attempts, lastError: message, updatedAt: new Date() })
+        .where(eq(channelContentPushIntents.id, id));
+}
+function rateLimitConfigForChannel(channel) {
+    if (!channel.rateLimitRps || !channel.rateLimitBurst)
+        return null;
+    return {
+        rps: channel.rateLimitRps,
+        burst: channel.rateLimitBurst,
+        priorityGates: channel.rateLimitPriorityGates ?? undefined,
+    };
+}
+function buildMinimalContent(product) {
+    // v1 minimal shape — enough for the demo upstream to acknowledge.
+    // Production wiring composes per-vertical content (itinerary, media,
+    // options, …) per the doc's `GetContentResult`.
+    return {
+        id: product.id,
+        name: product.name,
+        description: product.description ?? null,
+    };
+}
+/**
+ * Stable canonical-JSON hash. Mirrors the body-fingerprint behavior
+ * of `webhook-deliveries.ts` — purely a "is this the same content as
+ * before?" fingerprint, not a cryptographic hash.
+ */
+export function canonicalHash(value) {
+    let text;
+    try {
+        text = canonicalJson(value);
+    }
+    catch {
+        text = String(value);
+    }
+    let h = 0xcbf29ce484222325n;
+    const prime = 0x100000001b3n;
+    const mask = 0xffffffffffffffffn;
+    for (let i = 0; i < text.length; i++) {
+        h ^= BigInt(text.charCodeAt(i));
+        h = (h * prime) & mask;
+    }
+    return h.toString(16).padStart(16, "0");
+}
+function canonicalJson(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    const keys = Object.keys(value).sort();
+    const parts = keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`);
+    return `{${parts.join(",")}}`;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * `@voyant-travel/distribution` — outbound channel-push pipeline.
+ *
+ * Per docs/architecture/channel-push-architecture.md.
+ */
+export { type ChannelPushAdminRoutes, createChannelPushAdminRoutes, } from "./admin-routes.js";
+export { CHANNEL_AVAILABILITY_PUSH_WORKFLOW_ID, type ProcessAvailabilityPushInput, type ProcessAvailabilityPushResult, processAvailabilityPushIntents, type ResolveAllotmentTargetsForSlotInput, resolveAllotmentTargetsForSlot, upsertAvailabilityIntent, } from "./availability-push.js";
+export { bookingPushIdempotencyKey, CHANNEL_BOOKING_PUSH_WORKFLOW_ID, type ProcessBookingPushInput, type ProcessBookingPushResult, processBookingPush, resolveBookingPushTargets, upsertPendingBookingLinks, } from "./booking-push.js";
+export { CHANNEL_CONTENT_PUSH_WORKFLOW_ID, canonicalHash, type ProcessContentPushInput, type ProcessContentPushResult, processContentPushIntents, resolveContentPushTargets, upsertContentIntent, } from "./content-push.js";
+export { type ChannelPushPluginOptions, channelPushPlugin, } from "./plugin.js";
+export { type AvailabilityReconcilerOptions, type BookingLinkReconcilerOptions, type ContentReconcilerOptions, type ReconcilerResult, reconcileAvailability, reconcileBookingLinks, reconcileContent, runAllReconcilers, } from "./reconciler.js";
+export { type ChannelPushSubscribersOptions, createChannelPushSubscribers, triggerBookingPushForBooking, } from "./subscriber.js";
+export { type ChannelPushDeps, type ChannelPushLogger, clearChannelPushDeps, defaultLogger, getChannelPushDeps, getChannelPushDepsOrThrow, setChannelPushDeps, } from "./types.js";
+export { channelAvailabilityPushWorkflow, channelBookingPushWorkflow, channelContentPushWorkflow, } from "./workflows.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/channel-push/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,KAAK,sBAAsB,EAC3B,4BAA4B,GAC7B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,qCAAqC,EACrC,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,8BAA8B,EAC9B,KAAK,mCAAmC,EACxC,8BAA8B,EAC9B,wBAAwB,GACzB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,yBAAyB,EACzB,gCAAgC,EAChC,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,kBAAkB,EAClB,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,gCAAgC,EAChC,aAAa,EACb,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,yBAAyB,EACzB,yBAAyB,EACzB,mBAAmB,GACpB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,KAAK,wBAAwB,EAC7B,iBAAiB,GAClB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,KAAK,6BAA6B,EAClC,4BAA4B,EAC5B,4BAA4B,GAC7B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,YAAY,CAAA;AAKnB,OAAO,EACL,+BAA+B,EAC/B,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,gBAAgB,CAAA"}

package/dist/channel-push/index.js

@@ -0,0 +1,18 @@
+/**
+ * `@voyant-travel/distribution` — outbound channel-push pipeline.
+ *
+ * Per docs/architecture/channel-push-architecture.md.
+ */
+export { createChannelPushAdminRoutes, } from "./admin-routes.js";
+export { CHANNEL_AVAILABILITY_PUSH_WORKFLOW_ID, processAvailabilityPushIntents, resolveAllotmentTargetsForSlot, upsertAvailabilityIntent, } from "./availability-push.js";
+export { bookingPushIdempotencyKey, CHANNEL_BOOKING_PUSH_WORKFLOW_ID, processBookingPush, resolveBookingPushTargets, upsertPendingBookingLinks, } from "./booking-push.js";
+export { CHANNEL_CONTENT_PUSH_WORKFLOW_ID, canonicalHash, processContentPushIntents, resolveContentPushTargets, upsertContentIntent, } from "./content-push.js";
+export { channelPushPlugin, } from "./plugin.js";
+export { reconcileAvailability, reconcileBookingLinks, reconcileContent, runAllReconcilers, } from "./reconciler.js";
+export { createChannelPushSubscribers, triggerBookingPushForBooking, } from "./subscriber.js";
+export { clearChannelPushDeps, defaultLogger, getChannelPushDeps, getChannelPushDepsOrThrow, setChannelPushDeps, } from "./types.js";
+// Importing this module registers all three durable workflows in the
+// process-local @voyant-travel/workflows registry. Hosts that don't run an
+// orchestrator (e.g. the operator starter's inline drain) can still
+// import safely — registration is a no-op without a runtime to dispatch.
+export { channelAvailabilityPushWorkflow, channelBookingPushWorkflow, channelContentPushWorkflow, } from "./workflows.js";

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

@@ -0,0 +1,18 @@
+/**
+ * Channel-push core plugin.
+ *
+ * Bundles the EventBus subscribers that listen to `booking.confirmed`
+ * (and later `availability.slot.changed`, `product.content.changed`)
+ * and writes durable intent rows.
+ *
+ * Templates wire this via `registerPlugins([channelPushPlugin({ ... })],
+ * { eventBus })` AFTER calling `setChannelPushDeps({ db, registry })`.
+ *
+ * Per docs/architecture/channel-push-architecture.md §4 + §10 (Phase D).
+ */
+import { type Plugin } from "@voyant-travel/core";
+import { type ChannelPushSubscribersOptions } from "./subscriber.js";
+export interface ChannelPushPluginOptions extends ChannelPushSubscribersOptions {
+}
+export declare function channelPushPlugin(options?: ChannelPushPluginOptions): Plugin;
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/channel-push/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,EAAE,KAAK,6BAA6B,EAAgC,MAAM,iBAAiB,CAAA;AAElG,MAAM,WAAW,wBAAyB,SAAQ,6BAA6B;CAAG;AAElF,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,MAAM,CAMhF"}

package/dist/channel-push/plugin.js

@@ -0,0 +1,21 @@
+/**
+ * Channel-push core plugin.
+ *
+ * Bundles the EventBus subscribers that listen to `booking.confirmed`
+ * (and later `availability.slot.changed`, `product.content.changed`)
+ * and writes durable intent rows.
+ *
+ * Templates wire this via `registerPlugins([channelPushPlugin({ ... })],
+ * { eventBus })` AFTER calling `setChannelPushDeps({ db, registry })`.
+ *
+ * Per docs/architecture/channel-push-architecture.md §4 + §10 (Phase D).
+ */
+import { definePlugin } from "@voyant-travel/core";
+import { createChannelPushSubscribers } from "./subscriber.js";
+export function channelPushPlugin(options = {}) {
+    return definePlugin({
+        name: "channel-push",
+        version: "0.1.0",
+        subscribers: createChannelPushSubscribers(options),
+    });
+}

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

@@ -0,0 +1,85 @@
+/**
+ * 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 { type ChannelPushDeps } from "./types.js";
+export interface BookingLinkReconcilerOptions {
+    /**
+     * Re-process links whose `lastPushAt` is older than this many ms (or
+     * has never been pushed). Default 15 min, matching the v1 cadence.
+     */
+    staleAfterMs?: number;
+    /** Max links to re-process per call. Default 200. */
+    limit?: number;
+    /** When set, scope the pass to one channel. */
+    channelId?: string;
+}
+export interface ReconcilerResult {
+    scanned: number;
+    triggered: number;
+}
+/**
+ * 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 declare function reconcileBookingLinks(options?: BookingLinkReconcilerOptions, deps?: ChannelPushDeps): Promise<ReconcilerResult>;
+export interface AvailabilityReconcilerOptions {
+    /** Look-back window for recent slot changes. Default 1 hour. */
+    lookbackMs?: number;
+    /** Max slots to enqueue per pass. Default 500. */
+    limit?: number;
+    channelId?: string;
+}
+/**
+ * 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 declare function reconcileAvailability(options?: AvailabilityReconcilerOptions, deps?: ChannelPushDeps): Promise<ReconcilerResult>;
+export interface ContentReconcilerOptions {
+    /** Max products to scan per pass. Default 200. */
+    limit?: number;
+    channelId?: string;
+}
+/**
+ * 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 declare function reconcileContent(options?: ContentReconcilerOptions, deps?: ChannelPushDeps): Promise<ReconcilerResult>;
+/**
+ * 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 declare function runAllReconcilers(deps?: ChannelPushDeps): Promise<{
+    bookings: ReconcilerResult;
+    availability: ReconcilerResult;
+    content: ReconcilerResult;
+}>;
+//# sourceMappingURL=reconciler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reconciler.d.ts","sourceRoot":"","sources":["../../src/channel-push/reconciler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAiBH,OAAO,EAAE,KAAK,eAAe,EAA4C,MAAM,YAAY,CAAA;AAE3F,MAAM,WAAW,4BAA4B;IAC3C;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,4BAAiC,EAC1C,IAAI,CAAC,EAAE,eAAe,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAqC3B;AAED,MAAM,WAAW,6BAA6B;IAC5C,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,6BAAkC,EAC3C,IAAI,CAAC,EAAE,eAAe,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAgE3B;AAED,MAAM,WAAW,wBAAwB;IACvC,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,GAAE,wBAA6B,EACtC,IAAI,CAAC,EAAE,eAAe,GACrB,OAAO,CAAC,gBAAgB,CAAC,CA8C3B;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC;IACvE,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,YAAY,EAAE,gBAAgB,CAAA;IAC9B,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAC,CAOD"}