@voyant-travel/catalog 0.117.2

package/dist/booking-engine/snapshot-content.js

@@ -0,0 +1,110 @@
+/**
+ * Snapshot content capture per sourced-content §5.1.
+ *
+ * The booking engine calls a `SnapshotContentCapturer` at commit time
+ * to refresh content from the adapter and embed the result in the
+ * snapshot's `frozen_payload.content_capture` envelope. The
+ * capturer's contract is "refresh-with-fallback":
+ *
+ *   1. Try to fetch fresh content from the adapter (and write through
+ *      to the per-vertical content cache so the next read sees the
+ *      fresh row).
+ *   2. On adapter error (network blip, rate limit, transient outage),
+ *      fall back to the cache — including stale rows.
+ *   3. If neither is available, throw `SnapshotContentUnavailableError`.
+ *      The booking engine propagates this and aborts the commit. We
+ *      deliberately do NOT snapshot from the indexed projection —
+ *      refunds and audit need real "what was sold" content, not a
+ *      stub.
+ *
+ * The orchestrator stays in the booking-engine sub-package because the
+ * envelope shape, error types, and integration point all live with
+ * `bookEntity`. Per-vertical content services (products, cruises,
+ * etc.) implement `ContentSnapshotAdapter` and the template wires them
+ * into a single capturer via `composeSnapshotContentCapturer`.
+ *
+ * See `docs/architecture/catalog-sourced-content.md` §5.1.
+ */
+import { SnapshotContentUnavailableError } from "./errors.js";
+/**
+ * Compose a `SnapshotContentCapturer` from a registry of per-vertical
+ * `ContentSnapshotAdapter`s and an adapter registry. Use when the
+ * template wants the §5.1 refresh-with-fallback behavior wired
+ * uniformly across verticals.
+ *
+ * Returns null when:
+ *   - The entity_module isn't in the per-vertical adapter map
+ *     (assumed owned or out-of-scope; engine skips the envelope).
+ *   - The source adapter for `source_kind` doesn't implement
+ *     `getContent` AND no cache row exists. (When `getContent` is
+ *     missing but a cache row exists, we serve the cache row — the
+ *     vertical's synthesizer is for read paths, not write paths.)
+ *
+ * Throws `SnapshotContentUnavailableError` when neither fresh nor
+ * cached content can be produced.
+ */
+export function composeSnapshotContentCapturer(options) {
+    return async function captureSnapshotContent(input) {
+        const verticalAdapter = options.contentAdapters.get(input.entity_module);
+        if (!verticalAdapter) {
+            // No content service for this vertical → owned or out-of-scope.
+            return null;
+        }
+        const sourceAdapter = input.source_connection_id
+            ? (options.registry.resolveByConnection(input.source_connection_id) ??
+                options.registry.byKind(input.source_kind)[0]?.adapter)
+            : options.registry.byKind(input.source_kind)[0]?.adapter;
+        if (!sourceAdapter) {
+            // No source adapter registered. Try cache fallback first; if
+            // even that fails, signal unavailable so the engine can abort.
+            return readCachedOrThrow(verticalAdapter, input, "no source adapter registered");
+        }
+        const request = {
+            entity_module: input.entity_module,
+            entity_id: input.entity_id,
+            locale: input.locale,
+            market: input.market,
+            currency: input.currency,
+        };
+        if (sourceAdapter.getContent) {
+            try {
+                const fresh = await verticalAdapter.refresh(input.db, sourceAdapter, input.adapterContext, request);
+                return {
+                    source: "fresh",
+                    fetched_at: new Date(),
+                    content_etag: fresh.etag,
+                    content_schema_version: fresh.content_schema_version,
+                    content: fresh.content,
+                };
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                return readCachedOrThrow(verticalAdapter, input, reason);
+            }
+        }
+        // Adapter is thin (no getContent). Cache-or-throw — synthesizer
+        // is read-time only, not snapshot-time.
+        return readCachedOrThrow(verticalAdapter, input, "adapter does not implement getContent");
+    };
+}
+async function readCachedOrThrow(verticalAdapter, input, fallbackReason) {
+    const request = {
+        entity_module: input.entity_module,
+        entity_id: input.entity_id,
+        locale: input.locale,
+        market: input.market,
+        currency: input.currency,
+    };
+    const cached = await verticalAdapter.readCached(input.db, request);
+    if (!cached) {
+        throw new SnapshotContentUnavailableError(input.entity_module, input.entity_id, fallbackReason);
+    }
+    return {
+        source: "cache_fallback",
+        fetched_at: cached.fetched_at,
+        fallback_reason: fallbackReason,
+        content_etag: cached.etag ?? undefined,
+        content_schema_version: cached.content_schema_version,
+        content: cached.payload,
+    };
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot-content.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-content.test.d.ts","sourceRoot":"","sources":["../../src/booking-engine/snapshot-content.test.ts"],"names":[],"mappings":""}

package/dist/booking-engine/snapshot-content.test.js

@@ -0,0 +1,213 @@
+import { describe, expect, it, vi } from "vitest";
+import { SnapshotContentUnavailableError } from "./errors.js";
+import { createSourceAdapterRegistry } from "./registry.js";
+import { composeSnapshotContentCapturer, } from "./snapshot-content.js";
+function fakeDb() {
+    return {};
+}
+function makeRichAdapter(getContent) {
+    return {
+        kind: "rich",
+        capabilities: {
+            verticals: ["products"],
+            supportsLiveResolution: false,
+            supportsDriftDetection: false,
+            supportsBookingForwarding: false,
+            postBookOperations: [],
+            supportsContentFetch: true,
+        },
+        connect: async () => undefined,
+        pause: async () => undefined,
+        disconnect: async () => undefined,
+        getState: async () => "active",
+        discover: async () => ({ projections: [], next_cursor: undefined }),
+        getContent,
+    };
+}
+function makeThinAdapter() {
+    return {
+        kind: "thin",
+        capabilities: {
+            verticals: ["products"],
+            supportsLiveResolution: false,
+            supportsDriftDetection: false,
+            supportsBookingForwarding: false,
+            postBookOperations: [],
+            supportsContentFetch: false,
+        },
+        connect: async () => undefined,
+        pause: async () => undefined,
+        disconnect: async () => undefined,
+        getState: async () => "active",
+        discover: async () => ({ projections: [], next_cursor: undefined }),
+    };
+}
+const baseInput = {
+    db: fakeDb(),
+    entity_module: "products",
+    entity_id: "prod_abc",
+    source_kind: "rich",
+    source_connection_id: "conn_1",
+    source_ref: "REF-1",
+    locale: "en-GB",
+    market: "GB",
+    currency: "GBP",
+    adapterContext: { connection_id: "conn_1" },
+};
+describe("composeSnapshotContentCapturer — refresh-with-fallback per §5.1", () => {
+    it("returns null when the entity_module isn't in the per-vertical map (owned / out-of-scope)", async () => {
+        const registry = createSourceAdapterRegistry();
+        const capturer = composeSnapshotContentCapturer({
+            registry,
+            contentAdapters: new Map(),
+        });
+        const result = await capturer({ ...baseInput, entity_module: "owned-vertical" });
+        expect(result).toBeNull();
+    });
+    it("returns 'fresh' when the adapter call succeeds — writes through to cache", async () => {
+        const fresh = {
+            entity_module: "products",
+            entity_id: "prod_abc",
+            source_ref: "REF-1",
+            returned_locale: "en-GB",
+            content: { product: { id: "prod_abc", name: "Sample" } },
+            content_schema_version: "products/v1",
+            etag: 'W/"abc"',
+        };
+        const refresh = vi.fn(async () => fresh);
+        const verticalAdapter = {
+            refresh,
+            readCached: async () => null,
+        };
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeRichAdapter(async () => fresh));
+        const capturer = composeSnapshotContentCapturer({
+            registry,
+            contentAdapters: new Map([["products", verticalAdapter]]),
+        });
+        const result = await capturer(baseInput);
+        expect(result).not.toBeNull();
+        expect(result?.source).toBe("fresh");
+        expect(result?.content_schema_version).toBe("products/v1");
+        expect(result?.content_etag).toBe('W/"abc"');
+        expect(result?.content).toEqual({ product: { id: "prod_abc", name: "Sample" } });
+        expect(refresh).toHaveBeenCalledTimes(1);
+    });
+    it("falls back to cache when adapter.getContent throws", async () => {
+        const cachedFetchedAt = new Date("2026-04-01T12:00:00Z");
+        const verticalAdapter = {
+            refresh: vi.fn(async () => {
+                throw new Error("upstream rate-limit");
+            }),
+            readCached: vi.fn(async () => ({
+                payload: { product: { id: "prod_abc", name: "Sample (cached)" } },
+                content_schema_version: "products/v1",
+                fetched_at: cachedFetchedAt,
+                etag: 'W/"old"',
+            })),
+        };
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeRichAdapter(async () => {
+            throw new Error("upstream rate-limit");
+        }));
+        const capturer = composeSnapshotContentCapturer({
+            registry,
+            contentAdapters: new Map([["products", verticalAdapter]]),
+        });
+        const result = await capturer(baseInput);
+        expect(result?.source).toBe("cache_fallback");
+        expect(result?.fallback_reason).toBe("upstream rate-limit");
+        expect(result?.fetched_at).toEqual(cachedFetchedAt);
+        expect(result?.content).toEqual({ product: { id: "prod_abc", name: "Sample (cached)" } });
+    });
+    it("throws SnapshotContentUnavailableError when neither fresh nor cached produces content", async () => {
+        const verticalAdapter = {
+            refresh: async () => {
+                throw new Error("upstream down");
+            },
+            readCached: async () => null,
+        };
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeRichAdapter(async () => {
+            throw new Error("upstream down");
+        }));
+        const capturer = composeSnapshotContentCapturer({
+            registry,
+            contentAdapters: new Map([["products", verticalAdapter]]),
+        });
+        await expect(capturer(baseInput)).rejects.toBeInstanceOf(SnapshotContentUnavailableError);
+    });
+    it("returns cache-fallback when adapter is thin and a cache row exists", async () => {
+        const cachedFetchedAt = new Date("2026-03-01T00:00:00Z");
+        const verticalAdapter = {
+            refresh: async () => {
+                throw new Error("should not be called for thin adapter");
+            },
+            readCached: async () => ({
+                payload: { product: { id: "prod_abc", name: "Sample" } },
+                content_schema_version: "products/v1",
+                fetched_at: cachedFetchedAt,
+                etag: null,
+            }),
+        };
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeThinAdapter());
+        const capturer = composeSnapshotContentCapturer({
+            registry,
+            contentAdapters: new Map([["products", verticalAdapter]]),
+        });
+        const result = await capturer({ ...baseInput, source_kind: "thin" });
+        expect(result?.source).toBe("cache_fallback");
+        expect(result?.fallback_reason).toContain("does not implement getContent");
+    });
+    it("throws when adapter is thin and no cache row exists", async () => {
+        const verticalAdapter = {
+            refresh: async () => {
+                throw new Error("never");
+            },
+            readCached: async () => null,
+        };
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeThinAdapter());
+        const capturer = composeSnapshotContentCapturer({
+            registry,
+            contentAdapters: new Map([["products", verticalAdapter]]),
+        });
+        await expect(capturer({ ...baseInput, source_kind: "thin" })).rejects.toBeInstanceOf(SnapshotContentUnavailableError);
+    });
+    it("threads the request scope (locale/market/currency) into refresh + readCached", async () => {
+        const seenRequests = [];
+        const verticalAdapter = {
+            refresh: async (_db, _adapter, _ctx, request) => {
+                seenRequests.push(request);
+                return {
+                    entity_module: request.entity_module,
+                    entity_id: request.entity_id,
+                    source_ref: "REF-1",
+                    returned_locale: request.locale,
+                    content: {},
+                    content_schema_version: "products/v1",
+                };
+            },
+            readCached: async () => null,
+        };
+        const registry = createSourceAdapterRegistry();
+        registry.register(makeRichAdapter(async () => ({
+            entity_module: "products",
+            entity_id: "prod_abc",
+            source_ref: "REF-1",
+            returned_locale: "ro-RO",
+            content: {},
+            content_schema_version: "products/v1",
+        })));
+        const capturer = composeSnapshotContentCapturer({
+            registry,
+            contentAdapters: new Map([["products", verticalAdapter]]),
+        });
+        await capturer({ ...baseInput, locale: "ro-RO", market: "RO", currency: "RON" });
+        expect(seenRequests).toHaveLength(1);
+        expect(seenRequests[0]?.locale).toBe("ro-RO");
+        expect(seenRequests[0]?.market).toBe("RO");
+        expect(seenRequests[0]?.currency).toBe("RON");
+    });
+});

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

@@ -0,0 +1,136 @@
+/**
+ * Source discovery sync — pulls projections from every registered
+ * `SourceAdapter` and pushes them into the deployment's indexer so
+ * sourced inventory shows up in the catalog UI alongside owned rows.
+ *
+ * Mirrors the bulk reindex flow (`scripts/reindex.ts` in operator
+ * templates) for owned rows, except the data comes from
+ * `adapter.discover()` instead of a Drizzle table scan.
+ *
+ * The orchestrator is pure: it takes the registry, the indexer service,
+ * and the per-vertical field-policy registries, and returns a summary
+ * of what was synced. Templates wire env / Typesense / embeddings; this
+ * function only touches what was passed in.
+ *
+ * Usage pattern (in a template script):
+ *
+ *   const summary = await syncSources({
+ *     registry,
+ *     indexerService,
+ *     fieldPolicyRegistries,
+ *   })
+ *
+ * Drift events, scheduled re-runs, and concurrency limits are deferred
+ * to the catalog plane's normal drift pipeline (foundation §5.5);
+ * `syncSources` is a one-shot bulk pass driven by a CLI or cron job.
+ */
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import type { SourceAdapter, SourceAdapterContext } from "../adapter/contract.js";
+import type { FieldPolicyRegistry } from "../contract.js";
+import type { DocumentBuilder, IndexerService } from "../services/indexer-service.js";
+import type { SourceAdapterRegistry } from "./registry.js";
+export interface SyncSourcesOptions {
+    /** Booking-engine registry — every registered adapter's `discover` is fanned out. */
+    registry: SourceAdapterRegistry;
+    /** Indexer the projections land in. Caller passes the same instance the live route uses. */
+    indexerService: IndexerService;
+    /**
+     * Per-vertical field-policy registries keyed by `entity_module`.
+     * Same shape the indexer service is built with; passed separately so
+     * the sync can build documents from projections without re-reading
+     * the registry from the indexer service.
+     */
+    fieldPolicyRegistries: ReadonlyMap<string, FieldPolicyRegistry>;
+    /**
+     * Drizzle DB handle. When set, sync upserts a row into
+     * `catalog_sourced_entries` for every sourced projection (the durable
+     * provenance + projection-capture store, sourced-content §2.5). The
+     * upsert is idempotent on `(entity_module, entity_id)` and runs before
+     * the indexer write. Owned projections are skipped — they live in the
+     * vertical's owned schema, not the sourced-entry store.
+     *
+     * Optional only because pure-indexer test setups (no DB) want to use
+     * `syncSources` for indexer-shape coverage. Production wiring always
+     * passes a DB.
+     */
+    db?: AnyDrizzleDb;
+    /**
+     * Optional adapter context override. Most adapters need at minimum
+     * a `connection_id`; the demo plugin doesn't care so the default
+     * `{ connection_id: adapter.kind }` is sufficient. Templates with
+     * real connections pass their connection id (or build a per-adapter
+     * map keyed by `kind`).
+     */
+    buildAdapterContext?: (adapter: SourceAdapter) => SourceAdapterContext;
+    /**
+     * Optional wrapper around the per-projection `DocumentBuilder` — used
+     * to attach embeddings via `withEmbedding` (the operator starter's
+     * helper) without coupling this orchestrator to any embedding
+     * provider.
+     */
+    wrapBuilder?: (builder: DocumentBuilder) => DocumentBuilder;
+    /** Per-page log hook — called every page so callers can show progress. */
+    onProgress?: (event: SyncProgressEvent) => void;
+    /**
+     * Optional vertical allow-list. Scheduled vertical refreshes use this to run
+     * only the adapter projections relevant to the current job.
+     */
+    verticals?: ReadonlyArray<string>;
+    /**
+     * When true, rows from the same source/connection/vertical that were not
+     * emitted by a successful discovery pass are marked withdrawn and deleted
+     * from catalog search slices. Failed adapter passes never prune.
+     */
+    pruneMissing?: boolean;
+}
+export interface SyncProgressEvent {
+    adapter: string;
+    page: number;
+    pageSize: number;
+    totalSoFar: number;
+}
+export interface SyncAdapterSummary {
+    adapter: string;
+    pages: number;
+    projectionsSynced: number;
+    /**
+     * Verticals the adapter touched, derived from `entity_module` on
+     * each projection. Useful for the CLI to print per-vertical counts.
+     */
+    verticalsTouched: string[];
+    /**
+     * Projections skipped because no field-policy registry was registered
+     * for their `entity_module`. Common when an adapter declares more
+     * verticals than the deployment indexes.
+     */
+    skippedNoRegistry: number;
+    /**
+     * Projections that landed in `catalog_sourced_entries` (sourced rows
+     * with a DB handle in scope). Owned projections are not counted —
+     * they're not part of the sourced-entry store.
+     */
+    sourcedEntriesUpserted: number;
+    /**
+     * Owned projections passed through unchanged. Owned-flagged
+     * projections via `discover()` are an unusual case (most adapters
+     * emit only sourced rows) but the orchestrator still routes them to
+     * the indexer.
+     */
+    ownedProjections: number;
+    /**
+     * Previously active sourced rows that were not emitted by a successful
+     * discovery pass, marked withdrawn and removed from search slices.
+     */
+    withdrawnProjections: number;
+}
+export interface SyncSourcesSummary {
+    adapters: SyncAdapterSummary[];
+    totalProjections: number;
+}
+/**
+ * Run a one-shot discovery sync against every registered adapter.
+ * Throws if an adapter doesn't support `discover` (a contract violation —
+ * adapters wishing to participate in the sync must implement it).
+ */
+export declare function syncSources(options: SyncSourcesOptions): Promise<SyncSourcesSummary>;
+//# sourceMappingURL=sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/booking-engine/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AACjF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAGzD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAOrF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAE1D,MAAM,WAAW,kBAAkB;IACjC,qFAAqF;IACrF,QAAQ,EAAE,qBAAqB,CAAA;IAC/B,4FAA4F;IAC5F,cAAc,EAAE,cAAc,CAAA;IAC9B;;;;;OAKG;IACH,qBAAqB,EAAE,WAAW,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IAC/D;;;;;;;;;;;OAWG;IACH,EAAE,CAAC,EAAE,YAAY,CAAA;IACjB;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,oBAAoB,CAAA;IACtE;;;;;OAKG;IACH,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,eAAe,CAAA;IAC3D,0EAA0E;IAC1E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;IAC/C;;;OAGG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACjC;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;;OAIG;IACH,sBAAsB,EAAE,MAAM,CAAA;IAC9B;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,kBAAkB,EAAE,CAAA;IAC9B,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA6H1F"}

package/dist/booking-engine/sync.js

@@ -0,0 +1,177 @@
+/**
+ * Source discovery sync — pulls projections from every registered
+ * `SourceAdapter` and pushes them into the deployment's indexer so
+ * sourced inventory shows up in the catalog UI alongside owned rows.
+ *
+ * Mirrors the bulk reindex flow (`scripts/reindex.ts` in operator
+ * templates) for owned rows, except the data comes from
+ * `adapter.discover()` instead of a Drizzle table scan.
+ *
+ * The orchestrator is pure: it takes the registry, the indexer service,
+ * and the per-vertical field-policy registries, and returns a summary
+ * of what was synced. Templates wire env / Typesense / embeddings; this
+ * function only touches what was passed in.
+ *
+ * Usage pattern (in a template script):
+ *
+ *   const summary = await syncSources({
+ *     registry,
+ *     indexerService,
+ *     fieldPolicyRegistries,
+ *   })
+ *
+ * Drift events, scheduled re-runs, and concurrency limits are deferred
+ * to the catalog plane's normal drift pipeline (foundation §5.5);
+ * `syncSources` is a one-shot bulk pass driven by a CLI or cron job.
+ */
+import { isOwned } from "../provenance.js";
+import { buildIndexerDocument } from "../services/indexer-service.js";
+import { markMissingSourcedEntriesWithdrawn, upsertSourcedEntry, } from "../services/sourced-entry-service.js";
+/**
+ * Run a one-shot discovery sync against every registered adapter.
+ * Throws if an adapter doesn't support `discover` (a contract violation —
+ * adapters wishing to participate in the sync must implement it).
+ */
+export async function syncSources(options) {
+    const verticalFilter = options.verticals ? new Set(options.verticals) : undefined;
+    // Iterate every registered (connection_id, adapter) pair — multiple
+    // connections of the same kind each get their own discovery pass.
+    // Skip adapters that don't implement `discover` (outbound-only
+    // channel-push adapters).
+    const entries = options.registry
+        .connections()
+        .map((connectionId) => ({
+        connectionId,
+        adapter: options.registry.resolveByConnectionOrThrow(connectionId),
+    }))
+        .filter((e) => typeof e.adapter.discover === "function")
+        .filter((e) => !verticalFilter ||
+        e.adapter.capabilities.verticals.some((vertical) => verticalFilter.has(vertical)));
+    const adapterSummaries = [];
+    let totalProjections = 0;
+    for (const { connectionId, adapter } of entries) {
+        const adapterCtx = options.buildAdapterContext?.(adapter) ?? {
+            connection_id: connectionId,
+        };
+        const summary = {
+            adapter: adapter.kind,
+            pages: 0,
+            projectionsSynced: 0,
+            verticalsTouched: [],
+            skippedNoRegistry: 0,
+            sourcedEntriesUpserted: 0,
+            ownedProjections: 0,
+            withdrawnProjections: 0,
+        };
+        const verticals = new Set();
+        const seenBySource = new Map();
+        let cursor;
+        do {
+            // `discover` is optional in the contract; the filter above
+            // ensures we only iterate adapters that implement it.
+            const page = await adapter.discover?.(adapterCtx, cursor);
+            if (!page)
+                break;
+            summary.pages += 1;
+            options.onProgress?.({
+                adapter: adapter.kind,
+                page: summary.pages,
+                pageSize: page.projections.length,
+                totalSoFar: summary.projectionsSynced + page.projections.length,
+            });
+            for (const projection of page.projections) {
+                if (verticalFilter && !verticalFilter.has(projection.entity_module)) {
+                    continue;
+                }
+                const registry = options.fieldPolicyRegistries.get(projection.entity_module);
+                if (!registry) {
+                    summary.skippedNoRegistry += 1;
+                    continue;
+                }
+                verticals.add(projection.entity_module);
+                // Durable sourced-entry capture (sourced-content §2.5.2).
+                // Owned projections skip — they live in the vertical's owned
+                // schema. Sourced projections upsert before the indexer write so
+                // the sourced-entry store is the canonical local copy of what
+                // discover() said for downstream synthesizer reads.
+                if (isOwned(projection.provenance)) {
+                    summary.ownedProjections += 1;
+                }
+                else if (options.db) {
+                    await upsertSourcedEntry(options.db, { projection });
+                    summary.sourcedEntriesUpserted += 1;
+                    if (options.pruneMissing) {
+                        trackSeenSourcedProjection(seenBySource, {
+                            entityModule: projection.entity_module,
+                            entityId: projection.entity_id,
+                            sourceKind: projection.provenance.source_kind,
+                            sourceConnectionId: projection.provenance.source_connection_id,
+                        });
+                    }
+                }
+                const projectionMap = toProjectionMap(projection.fields);
+                const baseBuilder = async (_entityId, slice) => buildIndexerDocument(registry, projectionMap, slice, projection.entity_id);
+                const builder = options.wrapBuilder ? options.wrapBuilder(baseBuilder) : baseBuilder;
+                await options.indexerService.reindexEntity(projection.entity_module, projection.entity_id, builder);
+                summary.projectionsSynced += 1;
+                totalProjections += 1;
+            }
+            cursor = page.next_cursor;
+        } while (cursor);
+        if (options.pruneMissing && options.db) {
+            ensureAdapterVerticalPruneScopes(seenBySource, adapter, connectionId, verticalFilter);
+            for (const seen of seenBySource.values()) {
+                const withdrawn = await markMissingSourcedEntriesWithdrawn(options.db, {
+                    entityModule: seen.entityModule,
+                    sourceKind: seen.sourceKind,
+                    sourceConnectionId: seen.sourceConnectionId,
+                    seenEntityIds: seen.entityIds,
+                });
+                for (const row of withdrawn) {
+                    await options.indexerService.deleteEntity(row.entity_module, row.entity_id);
+                }
+                summary.withdrawnProjections += withdrawn.length;
+            }
+        }
+        summary.verticalsTouched = [...verticals];
+        adapterSummaries.push(summary);
+    }
+    return { adapters: adapterSummaries, totalProjections };
+}
+function toProjectionMap(fields) {
+    return new Map(Object.entries(fields));
+}
+function trackSeenSourcedProjection(seenBySource, input) {
+    const key = sourceScopeKey(input);
+    let seen = seenBySource.get(key);
+    if (!seen) {
+        seen = {
+            entityModule: input.entityModule,
+            sourceKind: input.sourceKind,
+            sourceConnectionId: input.sourceConnectionId,
+            entityIds: new Set(),
+        };
+        seenBySource.set(key, seen);
+    }
+    seen.entityIds.add(input.entityId);
+}
+function ensureAdapterVerticalPruneScopes(seenBySource, adapter, connectionId, verticalFilter) {
+    const verticals = adapter.capabilities.verticals.filter((vertical) => !verticalFilter || verticalFilter.has(vertical));
+    for (const entityModule of verticals) {
+        const input = {
+            entityModule,
+            sourceKind: adapter.kind,
+            sourceConnectionId: connectionId,
+        };
+        const key = sourceScopeKey(input);
+        if (seenBySource.has(key))
+            continue;
+        seenBySource.set(key, {
+            ...input,
+            entityIds: new Set(),
+        });
+    }
+}
+function sourceScopeKey(input) {
+    return `${input.entityModule}\u0000${input.sourceKind}\u0000${input.sourceConnectionId ?? ""}`;
+}

package/dist/booking-engine/sync.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sync.test.d.ts.map

package/dist/booking-engine/sync.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.test.d.ts","sourceRoot":"","sources":["../../src/booking-engine/sync.test.ts"],"names":[],"mappings":""}