@voyantjs/distribution 0.20.0 → 0.21.1

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

@@ -0,0 +1,256 @@
+/**
+ * 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 "@voyantjs/catalog";
+import { newId } from "@voyantjs/db/lib/typeid";
+import { products } from "@voyantjs/products/schema";
+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 { 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 db
+            .select()
+            .from(products)
+            .where(eq(products.id, intent.productId))
+            .limit(1));
+        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 @@
+/**
+ * `@voyantjs/distribution/channel-push` — 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 @@
+/**
+ * `@voyantjs/distribution/channel-push` — 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 @voyantjs/workflows registry. Hosts that don't run an
+// orchestrator (e.g. the operator template'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 "@voyantjs/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,gBAAgB,CAAA;AAE1D,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 "@voyantjs/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;AAeH,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,CAmC3B;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,CAkE3B;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,CA4C3B;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"}

package/dist/channel-push/reconciler.js

@@ -0,0 +1,175 @@
+/**
+ * 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 { availabilitySlots } from "@voyantjs/availability/schema";
+import { products } from "@voyantjs/products/schema";
+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 { 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(sql `${channelBookingLinks.pushStatus} <> 'ok'`, 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 db
+        .select()
+        .from(availabilitySlots)
+        .where(sql `${availabilitySlots.updatedAt} > ${lookback}`)
+        .orderBy(asc(availabilitySlots.updatedAt))
+        .limit(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,
+        product: products,
+    })
+        .from(channelProductMappings)
+        .innerJoin(products, eq(channelProductMappings.productId, products.id))
+        .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));
+    let triggered = 0;
+    for (const { mapping, product } of mappings) {
+        if (!mapping.sourceConnectionId)
+            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 "@voyantjs/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,gBAAgB,CAAA;AAiB/D,OAAO,EACL,KAAK,eAAe,EAIrB,MAAM,YAAY,CAAA;AAmDnB,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"}