@pattern-stack/codegen 0.15.1 → 0.15.3

package/dist/runtime/subsystems/integration/index.js

@@ -1,1356 +1,87 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __decorateParam = (index2, decorator) => (target, key) => decorator(target, key, index2);
-
-// runtime/subsystems/integration/integration-field-diff.protocol.ts
-import { z } from "zod";
-var FieldDiffValueSchema = z.object({
-  from: z.unknown(),
-  to: z.unknown()
-});
-var FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);
-
-// runtime/subsystems/integration/entity-change-source-registry.protocol.ts
-var UnknownEntityError = class extends Error {
-  constructor(entity, available) {
-    super(
-      `No change source registered for entity '${entity}'. Available: ${available.join(", ")}`
-    );
-    this.name = "UnknownEntityError";
-  }
-};
-
-// runtime/subsystems/integration/entity-change-source-registry.memory.ts
-var MemoryEntityChangeSourceRegistry = class {
-  constructor(sources) {
-    this.sources = sources;
-  }
-  sources;
-  get(name) {
-    const source = this.sources.get(name);
-    if (!source) {
-      throw new UnknownEntityError(name, [...this.sources.keys()]);
-    }
-    return source;
-  }
-  has(name) {
-    return this.sources.has(name);
-  }
-  entities() {
-    return [...this.sources.keys()];
-  }
-};
-
-// runtime/subsystems/integration/detection-config.schema.ts
-import { z as z2 } from "zod";
-var FieldMappingSchema = z2.object({
-  source: z2.string().min(1),
-  target: z2.string().min(1),
-  transform: z2.string().min(1).optional()
-});
-var ResolvedFilterSchema = z2.object({
-  field: z2.string().min(1),
-  op: z2.enum(["eq", "neq", "in", "nin", "gt", "gte", "lt", "lte"]),
-  value: z2.unknown()
-});
-var SystemModstampCursorSchema = z2.object({
-  kind: z2.literal("systemModstamp"),
-  field: z2.string().min(1)
-});
-var ReplayIdCursorSchema = z2.object({
-  kind: z2.literal("replayId"),
-  field: z2.string().min(1)
-});
-var TimestampCursorSchema = z2.object({
-  kind: z2.literal("timestamp"),
-  field: z2.string().min(1)
-});
-var EventIdCursorSchema = z2.object({
-  kind: z2.literal("eventId"),
-  field: z2.string().min(1)
-});
-var HistoryIdCursorSchema = z2.object({
-  kind: z2.literal("historyId"),
-  field: z2.string().min(1)
-});
-var SyncTokenCursorSchema = z2.object({
-  kind: z2.literal("syncToken"),
-  field: z2.string().min(1)
-});
-var CursorStrategySchema = z2.discriminatedUnion("kind", [
-  SystemModstampCursorSchema,
-  ReplayIdCursorSchema,
-  TimestampCursorSchema,
-  EventIdCursorSchema,
-  HistoryIdCursorSchema,
-  SyncTokenCursorSchema
-]);
-var CURSOR_DIVISIBILITY = {
-  systemModstamp: true,
-  timestamp: true,
-  replayId: true,
-  eventId: false,
-  historyId: false,
-  syncToken: false
-};
-function isDivisibleCursor(kind) {
-  return CURSOR_DIVISIBILITY[kind];
-}
-var PollDetectionSchema = z2.object({
-  cursor: CursorStrategySchema,
-  provenance: z2.enum(["poll", "cdc"]).optional()
-});
-var WebhookDetectionSchema = z2.object({
-  eventIdField: z2.string().min(1)
-});
-var PollModeSchema = z2.object({
-  mode: z2.literal("poll"),
-  poll: PollDetectionSchema,
-  mapping: z2.array(FieldMappingSchema).min(1),
-  filters: z2.array(ResolvedFilterSchema).default([])
-});
-var WebhookModeSchema = z2.object({
-  mode: z2.literal("webhook"),
-  webhook: WebhookDetectionSchema,
-  mapping: z2.array(FieldMappingSchema).min(1),
-  filters: z2.array(ResolvedFilterSchema).default([])
-});
-var DetectionConfigSchema = z2.discriminatedUnion("mode", [
-  PollModeSchema,
-  WebhookModeSchema
-]);
-
-// runtime/subsystems/integration/loopback.middleware.ts
-function createLoopbackMiddleware(store) {
-  return (next) => {
-    return async function* (subscription, cursor) {
-      for await (const change of next(subscription, cursor)) {
-        const isEcho = await store.isEchoOfOwnWrite(
-          subscription.domain,
-          change.externalId,
-          change.record
-        );
-        if (isEcho) continue;
-        yield change;
-      }
-    };
-  };
-}
-
-// runtime/subsystems/integration/poll-change-source.ts
-var PollChangeSource = class {
-  label;
-  adapter;
-  filters;
-  externalIdSourceField;
-  source;
-  /**
-   * When `poll.provenance === 'cdc'`, the field on the emitted record from
-   * which `Change<T>.dedupKey` is read — sourced from `poll.cursor.field`
-   * (Stripe-style event endpoints carry the event id on the record itself
-   * and the cursor advances over the same id). `null` for default poll
-   * provenance, which does NOT populate `dedupKey`.
-   */
-  dedupKeySourceField;
-  composed;
-  constructor(opts) {
-    if (opts.config.mode !== "poll") {
-      throw new Error(
-        `PollChangeSource requires DetectionConfig.mode === 'poll'; got '${opts.config.mode}'`
-      );
-    }
-    const config = opts.config;
-    const externalIdMapping = config.mapping.find(
-      (m) => m.target === "external_id"
-    );
-    if (!externalIdMapping) {
-      throw new Error(
-        "PollChangeSource: DetectionConfig.mapping must include an entry with target 'external_id' so emitted Change<T>.externalId can be populated"
-      );
-    }
-    this.externalIdSourceField = externalIdMapping.target;
-    this.adapter = opts.adapter;
-    this.filters = config.filters;
-    const isCdc = config.poll.provenance === "cdc";
-    this.source = isCdc ? "cdc" : "poll";
-    this.dedupKeySourceField = isCdc ? config.poll.cursor.field : null;
-    this.label = opts.label ?? `poll-change-source:${externalIdMapping.source}`;
-    const inner = (sub, cur) => this.fetch(sub, cur);
-    const middlewares = opts.middlewares ?? [];
-    this.composed = middlewares.reduceRight(
-      (next, mw) => mw(next),
-      inner
-    );
-  }
-  listChanges(subscription, cursor) {
-    return this.composed(subscription, cursor);
-  }
-  async *fetch(subscription, cursor) {
-    const ctx = {
-      subscription,
-      cursor,
-      filters: this.filters
-    };
-    for await (const { record, cursor: nextCursor } of this.adapter(ctx)) {
-      const externalIdRaw = record[this.externalIdSourceField];
-      if (typeof externalIdRaw !== "string" || externalIdRaw.length === 0) {
-        throw new Error(
-          `PollChangeSource: record missing string '${this.externalIdSourceField}' \u2014 emitted records MUST carry the canonical external id keyed by the mapping target`
-        );
-      }
-      let dedupKey;
-      if (this.dedupKeySourceField !== null) {
-        const dedupRaw = record[this.dedupKeySourceField];
-        if (typeof dedupRaw !== "string" || dedupRaw.length === 0) {
-          throw new Error(
-            `PollChangeSource: cdc-provenance record missing string '${this.dedupKeySourceField}' \u2014 when poll.provenance === 'cdc' the cursor.field must be present on each record so dedupKey can be populated`
-          );
-        }
-        dedupKey = dedupRaw;
-      }
-      const change = {
-        externalId: externalIdRaw,
-        // Polling cannot distinguish create vs. update vs. delete on its
-        // own — all yielded records are surfaced as 'updated'. The
-        // orchestrator's diff stage classifies create-vs-update against
-        // local state; soft-delete detection is out of scope for the
-        // primitive (consumer drives via tombstone records or a separate
-        // sweep — see ADR-033).
-        operation: "updated",
-        record,
-        cursor: nextCursor,
-        source: this.source,
-        ...dedupKey !== void 0 ? { dedupKey } : {}
-      };
-      yield change;
-    }
-  }
-};
-
-// runtime/subsystems/integration/incremental-read.ts
-async function mapConcurrent(ids, fn, limit) {
-  const out = /* @__PURE__ */ new Map();
-  if (ids.length === 0) return out;
-  const width = Math.max(1, Math.min(limit, ids.length));
-  let next = 0;
-  const worker = async () => {
-    while (next < ids.length) {
-      const idx = next++;
-      const id = ids[idx];
-      out.set(id, await fn(id));
-    }
-  };
-  await Promise.all(Array.from({ length: width }, worker));
-  return out;
-}
-var IncrementalReadBase = class {
-  /**
-   * Whether the vendor takes the request predicate server-side. Declared, not
-   * enforced here — surfaced into the emission manifest (R3) so the falsifier
-   * suite (R4) can record which adapters filter post-hydrate. `false` is the
-   * honest floor (e.g. Gmail without `q=`), handled via `matchesRecord`.
-   */
-  filterPushdown = false;
-  /** Max concurrent in-flight calls for a `mapConcurrent`-built `hydrate`. */
-  hydrateConcurrency = 10;
-  /** `Change<T>.source` provenance stamped by `listChanges`. */
-  changeSource = "poll";
-  /**
-   * Whether this source's cursor strategy is divisible (RFC-0003 §3). When
-   * `true` (default — sortable watermarks like `systemModstamp`/`timestamp`/
-   * `replayId`), `listChanges` emits each record's per-ref cursor, so the
-   * orchestrator may checkpoint mid-walk and a crash resumes from the last
-   * delivered ref.
-   *
-   * When `false` (atomic opaque tokens — Gmail `historyId`, Calendar
-   * `syncToken`), `listChanges` WITHHOLDS per-ref cursors and emits the
-   * end-of-walk token only on the final record, so the orchestrator's
-   * persist-last-yielded lifecycle can never persist an unresumable mid-walk
-   * token. The cost is blast-radius: an interrupted atomic run resumes
-   * all-or-nothing from the prior persisted token. For atomic *backfills* that
-   * radius is the whole enumerate walk — bound it with `ReadRequest.pageSize`
-   * (smaller pages ⇒ shorter walks per run). Per-page atomic checkpointing is a
-   * future refinement; R2 gates at end-of-walk.
-   *
-   * Codegen (R3) sets this from the strategy kind via `isDivisibleCursor`.
-   */
-  cursorDivisible = true;
-  // ---- Optional filter hooks — exactly one is live per `filterPushdown` ----
-  /** Pre-hydrate predicate over the cheap ref (preferred — avoids hydration). */
-  matchesRef(_ref, _filter) {
-    return true;
-  }
-  /** Post-hydrate predicate over the canonical record (the no-pushdown floor). */
-  matchesRecord(_record, _filter) {
-    return true;
-  }
-  /**
-   * Resolve the filter for a subscription when adapting to `listChanges`
-   * (which has no filter argument). Defaults to none; codegen wiring (R3)
-   * overrides this to thread `DetectionConfig.filters`.
-   */
-  filterFor(_subscription) {
-    return void 0;
-  }
-  // ---- PROVIDED by the base ----
-  /**
-   * Stream canonical records for a request. Filter is applied BEFORE hydrate
-   * (structural: a kept ref is hydrated, a rejected one never is), so an
-   * adapter cannot hydrate-then-discard. A hydrate miss (deleted mid-run) is
-   * skipped, never fabricated.
-   */
-  async *read(req, ctx) {
-    for await (const refPage of this.enumerate(req.mode, req.filter, req.pageSize, ctx)) {
-      const kept = refPage.filter((ref) => this.matchesRef(ref, req.filter));
-      if (kept.length === 0) continue;
-      const raws = await this.hydrate(
-        kept.map((ref) => ref.externalId),
-        ctx
-      );
-      for (const ref of kept) {
-        const raw = raws.get(ref.externalId);
-        if (raw === void 0 || raw === null) continue;
-        const record = this.toCanonical(raw);
-        if (record !== null && this.matchesRecord(record, req.filter)) {
-          yield { externalId: ref.externalId, record, raw, cursor: ref.cursor };
-        }
-      }
-    }
-  }
-  /**
-   * `RandomRead<T>` — single-record read, provided for free as
-   * `toCanonical ∘ hydrate([id])`. Reuses the adapter's batched fetch + miss
-   * tolerance; returns `null` for a missing or undecodable record.
-   */
-  async get(id, ctx) {
-    const raws = await this.hydrate([id], ctx);
-    const raw = raws.get(id);
-    if (raw === void 0 || raw === null) return null;
-    return this.toCanonical(raw);
-  }
-  /**
-   * `IChangeSource<T>` adaptation. Maps the orchestrator's by-value cursor to a
-   * `ReadMode` (`null` → `full` backfill, else `delta`), streams `read()`, and
-   * stamps each `SourcedRecord` into a `Change<T>`. All records surface as
-   * `'updated'`; the orchestrator's diff stage classifies create-vs-update and
-   * deletes arrive as tombstone refs (`toCanonical` may flag them).
-   *
-   * Cursor emission honors `cursorDivisible` (RFC-0003 §3). Divisible: each
-   * record carries its own per-ref cursor. Atomic: per-ref cursors are withheld
-   * (`undefined`, which the orchestrator skips persisting) and the end-of-walk
-   * token rides only on the final record — so a mid-walk crash never persists
-   * an unresumable token. If an atomic run yields no surviving records, no
-   * cursor is persisted and the next run re-reads the same (empty) delta — a
-   * bounded inefficiency, never data loss.
-   */
-  async *listChanges(subscription, cursor) {
-    const mode = cursor === null || cursor === void 0 ? { kind: "full" } : { kind: "delta", cursor };
-    const filter = this.filterFor(subscription);
-    const stream = this.read({ mode, filter }, { subscription });
-    if (this.cursorDivisible) {
-      for await (const sourced of stream) {
-        yield this.toChange(sourced, sourced.cursor);
-      }
-      return;
-    }
-    let prev = null;
-    for await (const sourced of stream) {
-      if (prev !== null) yield this.toChange(prev, void 0);
-      prev = sourced;
-    }
-    if (prev !== null) yield this.toChange(prev, prev.cursor);
-  }
-  /** Stamp a `SourcedRecord` into a `Change<T>` with an explicit emitted cursor. */
-  toChange(sourced, cursor) {
-    return {
-      externalId: sourced.externalId,
-      operation: "updated",
-      record: sourced.record,
-      cursor,
-      source: this.changeSource
-    };
-  }
-};
-
-// runtime/subsystems/integration/webhook-change-source.ts
-var WebhookChangeSource = class {
-  label;
-  queue;
-  externalIdSourceField;
-  eventIdSourceField;
-  composed;
-  constructor(opts) {
-    if (opts.config.mode !== "webhook") {
-      throw new Error(
-        `WebhookChangeSource requires DetectionConfig.mode === 'webhook'; got '${opts.config.mode}'`
-      );
-    }
-    const config = opts.config;
-    const externalIdMapping = config.mapping.find(
-      (m) => m.target === "external_id"
-    );
-    if (!externalIdMapping) {
-      throw new Error(
-        "WebhookChangeSource: DetectionConfig.mapping must include an entry with target 'external_id' so emitted Change<T>.externalId can be populated"
-      );
-    }
-    this.externalIdSourceField = externalIdMapping.target;
-    this.eventIdSourceField = config.webhook.eventIdField;
-    this.queue = opts.queue;
-    this.label = opts.label ?? `webhook-change-source:${externalIdMapping.source}`;
-    const inner = (sub, cur) => this.fetch(sub, cur);
-    const middlewares = opts.middlewares ?? [];
-    this.composed = middlewares.reduceRight(
-      (next, mw) => mw(next),
-      inner
-    );
-  }
-  listChanges(subscription, cursor) {
-    return this.composed(subscription, cursor);
-  }
-  async *fetch(subscription, cursor) {
-    const ctx = {
-      subscription,
-      cursor
-    };
-    for await (const { record, cursor: nextCursor } of this.queue(ctx)) {
-      const externalIdRaw = record[this.externalIdSourceField];
-      if (typeof externalIdRaw !== "string" || externalIdRaw.length === 0) {
-        throw new Error(
-          `WebhookChangeSource: record missing string '${this.externalIdSourceField}' \u2014 emitted records MUST carry the canonical external id keyed by the mapping target`
-        );
-      }
-      const eventIdRaw = record[this.eventIdSourceField];
-      if (typeof eventIdRaw !== "string" || eventIdRaw.length === 0) {
-        throw new Error(
-          `WebhookChangeSource: record missing string '${this.eventIdSourceField}' \u2014 webhook records MUST carry the event id (DetectionConfig.webhook.eventIdField) so Change<T>.dedupKey can be populated`
-        );
-      }
-      const change = {
-        externalId: externalIdRaw,
-        // Webhook mode cannot distinguish create vs. update vs. delete on
-        // its own — the orchestrator's diff stage handles classification.
-        // Tombstone / soft-delete detection is consumer-driven (same as
-        // poll mode — see ADR-033).
-        operation: "updated",
-        record,
-        cursor: nextCursor ?? null,
-        source: "webhook",
-        dedupKey: eventIdRaw
-      };
-      yield change;
-    }
-  }
-};
-
-// runtime/subsystems/integration/build-change-source.ts
-function buildChangeSource(cfg, fetch, middlewares = []) {
-  switch (cfg.mode) {
-    case "poll":
-      return new PollChangeSource({
-        adapter: fetch,
-        config: cfg,
-        middlewares
-      });
-    case "webhook":
-      return new WebhookChangeSource({
-        queue: fetch,
-        config: cfg,
-        middlewares
-      });
-  }
-}
-
-// runtime/subsystems/integration/integration.tokens.ts
-var INTEGRATION_CHANGE_SOURCE = "INTEGRATION_CHANGE_SOURCE";
-var INTEGRATION_CURSOR_STORE = "INTEGRATION_CURSOR_STORE";
-var INTEGRATION_FIELD_DIFFER = "INTEGRATION_FIELD_DIFFER";
-var INTEGRATION_SINK = "INTEGRATION_SINK";
-var INTEGRATION_RUN_RECORDER = "INTEGRATION_RUN_RECORDER";
-var INTEGRATION_MODULE_OPTIONS = "INTEGRATION_MODULE_OPTIONS";
-var INTEGRATION_MULTI_TENANT = "INTEGRATION_MULTI_TENANT";
-var ENTITY_CHANGE_SOURCE_REGISTRY = "ENTITY_CHANGE_SOURCE_REGISTRY";
-
-// runtime/subsystems/integration/integration-errors.ts
-var MissingTenantIdError = class extends Error {
-  name = "MissingTenantIdError";
-  constructor(operation) {
-    super(
-      `Missing tenantId for integration operation '${operation}'. IntegrationModule is configured with multiTenant: true \u2014 every call must include a non-null tenantId. Either pass the tenantId or disable multi-tenancy on the module.`
-    );
-  }
-};
-function assertTenantId(tenantId, options) {
-  if (!options.multiTenant) return;
-  if (tenantId === void 0 || tenantId === null) {
-    throw new MissingTenantIdError(options.operation);
-  }
-}
-
-// runtime/subsystems/integration/integration-audit.schema.ts
+import "../../../chunk-KVOWSC5S.js";
 import {
-  pgEnum,
-  pgTable,
-  uuid,
-  text,
-  jsonb,
-  integer,
-  boolean,
-  timestamp,
-  index,
-  uniqueIndex
-} from "drizzle-orm/pg-core";
-var integrationRunDirectionEnum = pgEnum("integration_run_direction", [
-  "inbound",
-  "outbound"
-]);
-var integrationRunActionEnum = pgEnum("integration_run_action", [
-  "poll",
-  "cdc",
-  "webhook",
-  "manual",
-  "writeback"
-]);
-var integrationRunStatusEnum = pgEnum("integration_run_status", [
-  "running",
-  "success",
-  "no_changes",
-  "failed"
-]);
-var integrationRunItemOperationEnum = pgEnum("integration_run_item_operation", [
-  "created",
-  "updated",
-  "deleted",
-  "noop"
-]);
-var integrationRunItemStatusEnum = pgEnum("integration_run_item_status", [
-  "success",
-  "failed",
-  "skipped"
-]);
-var integrationSubscriptions = pgTable(
-  "integration_subscriptions",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    connectionId: text("connection_id").notNull(),
-    adapter: text("adapter").notNull(),
-    domain: text("domain").notNull(),
-    externalRef: text("external_ref"),
-    enabled: boolean("enabled").notNull().default(true),
-    /**
-     * Per-subscription configuration bag. Strategies type it internally;
-     * e.g. polling strategies stash `{ batchSize, highWatermark }` here.
-     */
-    config: jsonb("config").notNull().default({}).$type(),
-    /**
-     * Opaque cursor persisted by `ICursorStore.put()`. NULL until the first
-     * successful run advances it.
-     */
-    cursor: jsonb("cursor").$type(),
-    lastIntegrationAt: timestamp("last_integration_at", { withTimezone: true }),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id"),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-  },
-  (t) => ({
-    /**
-     * Composite uniqueness per the epic shape. `external_ref` is nullable;
-     * Postgres treats NULLs as distinct in a UNIQUE constraint, which means
-     * two rows with the same `(connection_id, adapter, domain)` and NULL
-     * external_ref are allowed. That's intentional — a subscription with
-     * NULL external_ref covers the full domain, and duplicates there would
-     * be a consumer-layer modeling issue, not a schema concern.
-     */
-    uqIntegrationSubscriptionTuple: uniqueIndex("uq_integration_subscriptions_tuple").on(
-      t.connectionId,
-      t.adapter,
-      t.domain,
-      t.externalRef
-    ),
-    /** Scheduling query: list enabled subscriptions ordered by staleness. */
-    idxIntegrationSubscriptionsEnabledLastIntegration: index(
-      "idx_integration_subscriptions_enabled_last_integration"
-    ).on(t.enabled, t.lastIntegrationAt)
-  })
-);
-var integrationRuns = pgTable(
-  "integration_runs",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    subscriptionId: uuid("subscription_id").notNull().references(() => integrationSubscriptions.id, { onDelete: "cascade" }),
-    direction: integrationRunDirectionEnum("direction").notNull(),
-    action: integrationRunActionEnum("action").notNull(),
-    status: integrationRunStatusEnum("status").notNull().default("running"),
-    recordsFound: integer("records_found").notNull().default(0),
-    recordsProcessed: integer("records_processed").notNull().default(0),
-    cursorBefore: jsonb("cursor_before").$type(),
-    cursorAfter: jsonb("cursor_after").$type(),
-    durationMs: integer("duration_ms"),
-    error: text("error"),
-    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
-    completedAt: timestamp("completed_at", { withTimezone: true }),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id")
-  },
-  (t) => ({
-    /** Timeline read: "most recent runs for this subscription". */
-    idxIntegrationRunsSubscriptionStartedAt: index(
-      "idx_integration_runs_subscription_started_at"
-    ).on(t.subscriptionId, t.startedAt),
-    /** Stale-run sweeper: "runs that started > N minutes ago and are still running". */
-    idxIntegrationRunsStatusStartedAt: index("idx_integration_runs_status_started_at").on(
-      t.status,
-      t.startedAt
-    )
-  })
-);
-var integrationRunItems = pgTable(
-  "integration_run_items",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    integrationRunId: uuid("integration_run_id").notNull().references(() => integrationRuns.id, { onDelete: "cascade" }),
-    entityType: text("entity_type").notNull(),
-    externalId: text("external_id").notNull(),
-    localId: text("local_id"),
-    operation: integrationRunItemOperationEnum("operation").notNull(),
-    status: integrationRunItemStatusEnum("status").notNull(),
-    /**
-     * Structured per-field diff — ADR-0003 shape enforced by
-     * `FieldDiffSchema.parse` at the recorder service layer.
-     *
-     * Shape: `{ [fieldName]: { from: unknown, to: unknown } }`.
-     * Empty `{}` for `noop` items; `{ [field]: { from: null, to: <value> } }`
-     * for created items; `{ [field]: { from: <value>, to: null } }` for
-     * deleted items.
-     */
-    changedFields: jsonb("changed_fields").notNull().default({}).$type(),
-    title: text("title"),
-    error: text("error"),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
-    tenantId: text("tenant_id")
-  },
-  (t) => ({
-    /** Ordered timeline within a run. */
-    idxIntegrationRunItemsRunCreatedAt: index("idx_integration_run_items_run_created_at").on(
-      t.integrationRunId,
-      t.createdAt
-    ),
-    /** Per-record history: "every integration that touched opportunity/$extId". */
-    idxIntegrationRunItemsEntityExternal: index(
-      "idx_integration_run_items_entity_external"
-    ).on(t.entityType, t.externalId)
-  })
-);
-
-// runtime/subsystems/integration/integration-cursor-store.memory-backend.ts
-import { Injectable } from "@nestjs/common";
-var MemoryCursorStore = class {
-  /**
-   * Subscription-id → last persisted cursor. Public so tests can inspect
-   * or pre-seed state; production callers MUST go through `get`/`put`.
-   */
-  cursors = /* @__PURE__ */ new Map();
-  /**
-   * Seedable subscription metadata for `listAll` — the memory backend
-   * stores only `subscriptionId → cursor` in its write path, so the
-   * snapshot shape (`connectionId`, `adapter`, `domain`, `externalRef`,
-   * timestamps) has no natural source without test seeding. Tests populate
-   * this map; unseeded entries get empty-string metadata and `new Date(0)`
-   * timestamps so the shape stays stable. Production paths go through the
-   * Drizzle backend.
-   */
-  subscriptions = /* @__PURE__ */ new Map();
-  async get(subscriptionId, _tenantId) {
-    const value = this.cursors.get(subscriptionId);
-    return value === void 0 ? null : value;
-  }
-  async put(subscriptionId, cursor, _tenantId) {
-    this.cursors.set(subscriptionId, cursor);
-  }
-  async listAll(_tenantId) {
-    const snapshots = [];
-    for (const [subscriptionId, cursor] of this.cursors.entries()) {
-      const meta = this.subscriptions.get(subscriptionId);
-      snapshots.push({
-        subscriptionId,
-        connectionId: meta?.connectionId ?? "",
-        adapter: meta?.adapter ?? "",
-        domain: meta?.domain ?? "",
-        externalRef: meta?.externalRef ?? null,
-        cursor: cursor ?? null,
-        lastIntegrationAt: meta?.lastIntegrationAt ?? null,
-        updatedAt: meta?.updatedAt ?? /* @__PURE__ */ new Date(0),
-        tenantId: null
-      });
-    }
-    return snapshots.sort(
-      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
-    );
-  }
-  /** Reset state. Tests call this in `beforeEach`. */
-  clear() {
-    this.cursors.clear();
-    this.subscriptions.clear();
-  }
-};
-MemoryCursorStore = __decorateClass([
-  Injectable()
-], MemoryCursorStore);
-
-// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
-import { Injectable as Injectable2 } from "@nestjs/common";
-var MemoryRunRecorder = class {
-  /**
-   * All started runs keyed by id. Public so tests can inspect lifecycle
-   * transitions without poking through recording methods.
-   */
-  runs = /* @__PURE__ */ new Map();
-  /**
-   * Items keyed by `integration_run_id`, array order matches insertion order —
-   * mirrors the timeline the `(integration_run_id, created_at)` index produces
-   * in Postgres.
-   */
-  items = /* @__PURE__ */ new Map();
-  /**
-   * Seedable subscription metadata — tests populate this to make
-   * `listRecent` return meaningful `connectionId` values. The memory
-   * backend doesn't track subscriptions on its own (only runs + items), so
-   * this map is the intentional extension point: tests write entries for
-   * the subscription ids they use, production code never touches it.
-   */
-  subscriptions = /* @__PURE__ */ new Map();
-  async startRun(input) {
-    const id = crypto.randomUUID();
-    this.runs.set(id, {
-      id,
-      subscriptionId: input.subscriptionId,
-      direction: input.direction,
-      action: input.action,
-      status: "running",
-      cursorBefore: input.cursorBefore ?? null,
-      cursorAfter: null,
-      recordsFound: 0,
-      recordsProcessed: 0,
-      durationMs: null,
-      error: null,
-      tenantId: input.tenantId ?? null,
-      startedAt: /* @__PURE__ */ new Date(),
-      completedAt: null
-    });
-    this.items.set(id, []);
-    return { id };
-  }
-  async recordItem(input) {
-    FieldDiffSchema.parse(input.changedFields);
-    const bucket = this.items.get(input.integrationRunId);
-    if (!bucket) {
-      throw new Error(
-        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. Call startRun(...) first.`
-      );
-    }
-    bucket.push(input);
-  }
-  async completeRun(runId, input) {
-    const run = this.runs.get(runId);
-    if (!run) {
-      throw new Error(
-        `MemoryRunRecorder.completeRun: no run started for id '${runId}'.`
-      );
-    }
-    run.status = input.status;
-    run.recordsFound = input.recordsFound;
-    run.recordsProcessed = input.recordsProcessed;
-    run.cursorAfter = input.cursorAfter ?? null;
-    run.durationMs = input.durationMs;
-    run.error = input.error ?? null;
-    run.completedAt = /* @__PURE__ */ new Date();
-  }
-  async listRecent(limit, subscriptionId, _tenantId) {
-    const all = Array.from(this.runs.values());
-    const filtered = subscriptionId === void 0 ? all : all.filter((r) => r.subscriptionId === subscriptionId);
-    return filtered.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit).map((r) => ({
-      id: r.id,
-      subscriptionId: r.subscriptionId,
-      // connectionId is only knowable if the test seeded subscriptions
-      // metadata; empty string otherwise. The Drizzle backend resolves
-      // it via JOIN, which is the production path.
-      connectionId: this.subscriptions.get(r.subscriptionId)?.connectionId ?? "",
-      status: r.status,
-      startedAt: r.startedAt,
-      completedAt: r.completedAt,
-      recordsProcessed: r.recordsProcessed,
-      tenantId: r.tenantId
-    }));
-  }
-  /** Reset state. Tests call this in `beforeEach`. */
-  clear() {
-    this.runs.clear();
-    this.items.clear();
-    this.subscriptions.clear();
-  }
-  // ─── test ergonomics ─────────────────────────────────────────────────
-  /** All runs for a subscription, newest first. Timeline reads. */
-  getRunsForSubscription(subscriptionId) {
-    return Array.from(this.runs.values()).filter((r) => r.subscriptionId === subscriptionId).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
-  }
-  /** All item rows for a run, insertion-ordered. */
-  getItemsForRun(runId) {
-    return this.items.get(runId) ?? [];
-  }
-};
-MemoryRunRecorder = __decorateClass([
-  Injectable2()
-], MemoryRunRecorder);
-
-// runtime/subsystems/integration/deep-equal.differ.ts
-import { Injectable as Injectable3 } from "@nestjs/common";
-var DEFAULT_IGNORE_FIELDS = /* @__PURE__ */ new Set([
-  "id",
-  "createdAt",
-  "updatedAt",
-  "deletedAt",
-  "type",
-  "lastModifiedAt",
-  "fields",
-  "external_id",
-  "externalId",
-  "provider",
-  "provider_metadata",
-  "providerMetadata"
-]);
-var DeepEqualDiffer = class {
-  ignore;
-  constructor(opts = {}) {
-    if (opts.ignore && opts.ignore.length > 0) {
-      this.ignore = /* @__PURE__ */ new Set([...DEFAULT_IGNORE_FIELDS, ...opts.ignore]);
-    } else {
-      this.ignore = DEFAULT_IGNORE_FIELDS;
-    }
-  }
-  diff(existing, incoming, providerChangedFields) {
-    if (existing === null) {
-      const out2 = {};
-      for (const key of Object.keys(incoming)) {
-        if (this.ignore.has(key)) continue;
-        const value = incoming[key];
-        if (value === null || value === void 0) continue;
-        out2[key] = { from: null, to: value };
-      }
-      return Object.keys(out2).length === 0 ? "noop" : out2;
-    }
-    const candidates = /* @__PURE__ */ new Set();
-    if (providerChangedFields && providerChangedFields.length > 0) {
-      for (const key of providerChangedFields) {
-        if (!this.ignore.has(key)) candidates.add(key);
-      }
-    } else {
-      for (const key of Object.keys(incoming)) {
-        if (!this.ignore.has(key)) candidates.add(key);
-      }
-      for (const key of Object.keys(existing)) {
-        if (this.ignore.has(key)) continue;
-        if (!(key in incoming)) continue;
-        candidates.add(key);
-      }
-    }
-    const out = {};
-    for (const key of candidates) {
-      const before = existing[key];
-      const after = incoming[key];
-      if (!isEqual(before, after)) {
-        out[key] = { from: before ?? null, to: after ?? null };
-      }
-    }
-    return Object.keys(out).length === 0 ? "noop" : out;
-  }
-};
-DeepEqualDiffer = __decorateClass([
-  Injectable3()
-], DeepEqualDiffer);
-function isEqual(a, b) {
-  if (a === b) return true;
-  const na = normalize(a);
-  const nb = normalize(b);
-  if (na === nb) return true;
-  if (typeof na === "object" && typeof nb === "object" && na !== null && nb !== null) {
-    return deepEqualObject(na, nb);
-  }
-  const numericEqual = maybeNumericEqual(na, nb) || maybeNumericEqual(nb, na);
-  return numericEqual;
-}
-function normalize(value) {
-  if (value instanceof Date) return value.toISOString();
-  return value;
-}
-function maybeNumericEqual(a, b) {
-  if (typeof a !== "string" || typeof b !== "number") return false;
-  if (a.trim() === "") return false;
-  const parsed = Number(a);
-  if (!Number.isFinite(parsed)) return false;
-  return parsed === b;
-}
-function deepEqualObject(a, b) {
-  if (Array.isArray(a) !== Array.isArray(b)) return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
-  for (const key of aKeys) {
-    if (!(key in b)) return false;
-    if (!isEqual(a[key], b[key])) return false;
-  }
-  return true;
-}
-
-// runtime/subsystems/integration/execute-integration.use-case.ts
-import { Inject, Injectable as Injectable4, Logger, Optional } from "@nestjs/common";
-var ExecuteIntegrationUseCase = class {
-  constructor(source, cursors, differ, sink, recorder, multiTenant = false) {
-    this.source = source;
-    this.cursors = cursors;
-    this.differ = differ;
-    this.sink = sink;
-    this.recorder = recorder;
-    this.multiTenant = multiTenant;
-  }
-  source;
-  cursors;
-  differ;
-  sink;
-  recorder;
-  multiTenant;
-  logger = new Logger(ExecuteIntegrationUseCase.name);
-  async execute(input) {
-    assertTenantId(input.tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "execute"
-    });
-    const source = input.sourceOverride ?? this.source;
-    const startedAt = Date.now();
-    const cursorBefore = await this.cursors.get(input.subscription.id, input.tenantId);
-    const { id: runId } = await this.recorder.startRun({
-      subscriptionId: input.subscription.id,
-      direction: input.direction,
-      action: input.action,
-      cursorBefore,
-      tenantId: input.tenantId
-    });
-    let recordsFound = 0;
-    let recordsProcessed = 0;
-    let recordsFailed = 0;
-    let latestCursor = cursorBefore;
-    let cursorAdvanced = false;
-    let runError = null;
-    let status = "no_changes";
-    try {
-      for await (const change of source.listChanges(input.subscription, cursorBefore)) {
-        recordsFound++;
-        latestCursor = change.cursor;
-        cursorAdvanced = true;
-        try {
-          await this.processChange(runId, input, change);
-          recordsProcessed++;
-        } catch (err) {
-          recordsFailed++;
-          const message = err instanceof Error ? err.message : String(err);
-          this.logger.warn(
-            `integration item failed: subscription=${input.subscription.id} externalId=${change.externalId}: ${message}`
-          );
-          await this.recorder.recordItem({
-            integrationRunId: runId,
-            entityType: input.subscription.domain,
-            externalId: change.externalId,
-            operation: change.operation === "deleted" ? "deleted" : "updated",
-            status: "failed",
-            changedFields: {},
-            error: message,
-            tenantId: input.tenantId
-          });
-        }
-      }
-      if (recordsFailed > 0 && recordsProcessed === 0 && recordsFound > 0) {
-        status = "failed";
-        runError = `all ${recordsFailed} records failed`;
-      } else if (recordsFound === 0) {
-        status = "no_changes";
-      } else {
-        status = "success";
-      }
-    } catch (err) {
-      status = "failed";
-      runError = err instanceof Error ? err.message : String(err);
-      this.logger.error(
-        `integration source failed: subscription=${input.subscription.id}: ${runError}`
-      );
-    }
-    if (cursorAdvanced && latestCursor !== null && latestCursor !== void 0) {
-      try {
-        await this.cursors.put(input.subscription.id, latestCursor, input.tenantId);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        this.logger.error(
-          `cursor put failed: subscription=${input.subscription.id}: ${message}`
-        );
-        if (status !== "failed") {
-          status = "failed";
-          runError = `cursor put failed: ${message}`;
-        }
-      }
-    }
-    const durationMs = Date.now() - startedAt;
-    await this.recorder.completeRun(runId, {
-      status,
-      recordsFound,
-      recordsProcessed,
-      cursorAfter: cursorAdvanced ? latestCursor : cursorBefore,
-      durationMs,
-      error: runError
-    });
-    return {
-      runId,
-      status,
-      recordsFound,
-      recordsProcessed,
-      recordsFailed,
-      cursorBefore,
-      cursorAfter: cursorAdvanced ? latestCursor : cursorBefore,
-      durationMs,
-      error: runError
-    };
-  }
-  async processChange(runId, input, change) {
-    if (change.operation === "deleted") {
-      const result = await this.sink.softDeleteByExternalId(
-        input.userId,
-        change.externalId
-      );
-      await this.recorder.recordItem({
-        integrationRunId: runId,
-        entityType: input.subscription.domain,
-        externalId: change.externalId,
-        localId: result?.id ?? null,
-        operation: result ? "deleted" : "noop",
-        status: "success",
-        changedFields: {},
-        tenantId: input.tenantId
-      });
-      return;
-    }
-    const existing = await this.sink.findByExternalId(
-      input.userId,
-      change.externalId
-    );
-    const diff = this.differ.diff(
-      existing,
-      change.record,
-      change.providerChangedFields
-    );
-    if (diff === "noop") {
-      if (!this.sink.reprojectsOnNoop) {
-        await this.recorder.recordItem({
-          integrationRunId: runId,
-          entityType: input.subscription.domain,
-          externalId: change.externalId,
-          localId: null,
-          operation: "noop",
-          status: "success",
-          changedFields: {},
-          tenantId: input.tenantId
-        });
-        return;
-      }
-      const { id: noopLocalId } = await this.sink.upsertByExternalId(
-        input.userId,
-        change.record,
-        input.provider
-      );
-      await this.recorder.recordItem({
-        integrationRunId: runId,
-        entityType: input.subscription.domain,
-        externalId: change.externalId,
-        localId: noopLocalId,
-        operation: "noop",
-        status: "success",
-        changedFields: {},
-        tenantId: input.tenantId
-      });
-      return;
-    }
-    const { id: localId } = await this.sink.upsertByExternalId(
-      input.userId,
-      change.record,
-      input.provider
-    );
-    await this.recorder.recordItem({
-      integrationRunId: runId,
-      entityType: input.subscription.domain,
-      externalId: change.externalId,
-      localId,
-      operation: existing === null ? "created" : "updated",
-      status: "success",
-      changedFields: diff,
-      tenantId: input.tenantId
-    });
-  }
-};
-ExecuteIntegrationUseCase = __decorateClass([
-  Injectable4(),
-  __decorateParam(0, Inject(INTEGRATION_CHANGE_SOURCE)),
-  __decorateParam(1, Inject(INTEGRATION_CURSOR_STORE)),
-  __decorateParam(2, Inject(INTEGRATION_FIELD_DIFFER)),
-  __decorateParam(3, Inject(INTEGRATION_SINK)),
-  __decorateParam(4, Inject(INTEGRATION_RUN_RECORDER)),
-  __decorateParam(5, Optional()),
-  __decorateParam(5, Inject(INTEGRATION_MULTI_TENANT))
-], ExecuteIntegrationUseCase);
-
-// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
-import { Inject as Inject2, Injectable as Injectable5, Optional as Optional2 } from "@nestjs/common";
-import { and, desc, eq } from "drizzle-orm";
-
-// runtime/constants/tokens.ts
-var DRIZZLE = "DRIZZLE";
-
-// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
-var PostgresCursorStore = class {
-  constructor(db, multiTenant) {
-    this.db = db;
-    this.multiTenant = multiTenant ?? false;
-  }
-  db;
-  multiTenant;
-  async get(subscriptionId, tenantId) {
-    const where = this.buildWhere(subscriptionId, tenantId, "cursor.get");
-    const rows = await this.db.select({ cursor: integrationSubscriptions.cursor }).from(integrationSubscriptions).where(where).limit(1);
-    if (rows.length === 0) return null;
-    return rows[0]?.cursor ?? null;
-  }
-  async put(subscriptionId, cursor, tenantId) {
-    const where = this.buildWhere(subscriptionId, tenantId, "cursor.put");
-    await this.db.update(integrationSubscriptions).set({
-      cursor,
-      lastIntegrationAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(where);
-  }
-  async listAll(tenantId) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "cursor.listAll"
-    });
-    const where = this.multiTenant ? eq(integrationSubscriptions.tenantId, tenantId) : void 0;
-    const rows = await this.db.select({
-      id: integrationSubscriptions.id,
-      connectionId: integrationSubscriptions.connectionId,
-      adapter: integrationSubscriptions.adapter,
-      domain: integrationSubscriptions.domain,
-      externalRef: integrationSubscriptions.externalRef,
-      cursor: integrationSubscriptions.cursor,
-      lastIntegrationAt: integrationSubscriptions.lastIntegrationAt,
-      updatedAt: integrationSubscriptions.updatedAt,
-      tenantId: integrationSubscriptions.tenantId
-    }).from(integrationSubscriptions).where(where).orderBy(desc(integrationSubscriptions.updatedAt));
-    return rows.map((row) => ({
-      subscriptionId: row.id,
-      connectionId: row.connectionId,
-      adapter: row.adapter,
-      domain: row.domain,
-      externalRef: row.externalRef,
-      cursor: row.cursor ?? null,
-      lastIntegrationAt: row.lastIntegrationAt,
-      updatedAt: row.updatedAt,
-      tenantId: row.tenantId
-    }));
-  }
-  /**
-   * Centralized WHERE clause — `get` and `put` share identical semantics.
-   * Drift here would let a caller read under one tenancy rule and write
-   * under another.
-   */
-  buildWhere(subscriptionId, tenantId, operation) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation
-    });
-    if (this.multiTenant) {
-      return and(
-        eq(integrationSubscriptions.id, subscriptionId),
-        eq(integrationSubscriptions.tenantId, tenantId)
-      );
-    }
-    return eq(integrationSubscriptions.id, subscriptionId);
-  }
-};
-PostgresCursorStore = __decorateClass([
-  Injectable5(),
-  __decorateParam(0, Inject2(DRIZZLE)),
-  __decorateParam(1, Optional2()),
-  __decorateParam(1, Inject2(INTEGRATION_MULTI_TENANT))
-], PostgresCursorStore);
-
-// runtime/subsystems/integration/integration-run-recorder.drizzle-backend.ts
-import { Inject as Inject3, Injectable as Injectable6, Optional as Optional3 } from "@nestjs/common";
-import { and as and2, desc as desc2, eq as eq2 } from "drizzle-orm";
-var DrizzleIntegrationRunRecorder = class {
-  constructor(db, multiTenant) {
-    this.db = db;
-    this.multiTenant = multiTenant ?? false;
-  }
-  db;
-  multiTenant;
-  async startRun(input) {
-    assertTenantId(input.tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "startRun"
-    });
-    const rows = await this.db.insert(integrationRuns).values({
-      subscriptionId: input.subscriptionId,
-      direction: input.direction,
-      action: input.action,
-      status: "running",
-      cursorBefore: input.cursorBefore ?? null,
-      tenantId: input.tenantId ?? null
-    }).returning({ id: integrationRuns.id });
-    const id = rows[0]?.id;
-    if (!id) {
-      throw new Error("DrizzleIntegrationRunRecorder: INSERT RETURNING produced no id");
-    }
-    return { id };
-  }
-  async recordItem(input) {
-    assertTenantId(input.tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "recordItem"
-    });
-    FieldDiffSchema.parse(input.changedFields);
-    await this.db.insert(integrationRunItems).values({
-      integrationRunId: input.integrationRunId,
-      entityType: input.entityType,
-      externalId: input.externalId,
-      localId: input.localId ?? null,
-      operation: input.operation,
-      status: input.status,
-      changedFields: input.changedFields,
-      title: input.title ?? null,
-      error: input.error ?? null,
-      tenantId: input.tenantId ?? null
-    });
-  }
-  async listRecent(limit, subscriptionId, tenantId) {
-    assertTenantId(tenantId, {
-      multiTenant: this.multiTenant,
-      operation: "listRecent"
-    });
-    const conditions = [];
-    if (subscriptionId !== void 0) {
-      conditions.push(eq2(integrationRuns.subscriptionId, subscriptionId));
-    }
-    if (this.multiTenant) {
-      conditions.push(eq2(integrationRuns.tenantId, tenantId));
-    }
-    const where = conditions.length === 0 ? void 0 : conditions.length === 1 ? conditions[0] : and2(...conditions);
-    const rows = await this.db.select({
-      id: integrationRuns.id,
-      subscriptionId: integrationRuns.subscriptionId,
-      connectionId: integrationSubscriptions.connectionId,
-      status: integrationRuns.status,
-      startedAt: integrationRuns.startedAt,
-      completedAt: integrationRuns.completedAt,
-      recordsProcessed: integrationRuns.recordsProcessed,
-      tenantId: integrationRuns.tenantId
-    }).from(integrationRuns).innerJoin(
-      integrationSubscriptions,
-      eq2(integrationRuns.subscriptionId, integrationSubscriptions.id)
-    ).where(where).orderBy(desc2(integrationRuns.startedAt)).limit(limit);
-    return rows.map((row) => ({
-      id: row.id,
-      subscriptionId: row.subscriptionId,
-      connectionId: row.connectionId,
-      status: row.status,
-      startedAt: row.startedAt,
-      completedAt: row.completedAt,
-      recordsProcessed: row.recordsProcessed,
-      tenantId: row.tenantId
-    }));
-  }
-  async completeRun(runId, input) {
-    await this.db.update(integrationRuns).set({
-      status: input.status,
-      recordsFound: input.recordsFound,
-      recordsProcessed: input.recordsProcessed,
-      cursorAfter: input.cursorAfter ?? null,
-      durationMs: input.durationMs,
-      error: input.error ?? null,
-      completedAt: /* @__PURE__ */ new Date()
-    }).where(eq2(integrationRuns.id, runId));
-  }
-};
-DrizzleIntegrationRunRecorder = __decorateClass([
-  Injectable6(),
-  __decorateParam(0, Inject3(DRIZZLE)),
-  __decorateParam(1, Optional3()),
-  __decorateParam(1, Inject3(INTEGRATION_MULTI_TENANT))
-], DrizzleIntegrationRunRecorder);
-
-// runtime/subsystems/integration/integration.module.ts
-import { Module } from "@nestjs/common";
-var IntegrationModule = class {
-  static forRoot(options) {
-    const multiTenant = options.multiTenant ?? false;
-    const sharedProviders = [
-      { provide: INTEGRATION_MODULE_OPTIONS, useValue: options },
-      { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },
-      // Default differ — consumers can override by binding a different
-      // `IFieldDiffer<T>` to `INTEGRATION_FIELD_DIFFER` in their feature module.
-      { provide: INTEGRATION_FIELD_DIFFER, useValue: new DeepEqualDiffer() }
-    ];
-    const backendProviders = options.backend === "memory" ? [
-      // Wired as singletons via `useValue` so tests can pull
-      // them out via `moduleRef.get(MemoryCursorStore)` for
-      // direct assertions. Matches JOB-4 / MemoryJobStore shape.
-      { provide: MemoryCursorStore, useValue: new MemoryCursorStore() },
-      {
-        provide: INTEGRATION_CURSOR_STORE,
-        useExisting: MemoryCursorStore
-      },
-      { provide: MemoryRunRecorder, useValue: new MemoryRunRecorder() },
-      {
-        provide: INTEGRATION_RUN_RECORDER,
-        useExisting: MemoryRunRecorder
-      }
-    ] : [
-      // Drizzle backends — injected with DRIZZLE (provided by the
-      // consumer's DrizzleModule) + the INTEGRATION_MULTI_TENANT flag
-      // we bound above.
-      { provide: INTEGRATION_CURSOR_STORE, useClass: PostgresCursorStore },
-      { provide: INTEGRATION_RUN_RECORDER, useClass: DrizzleIntegrationRunRecorder }
-    ];
-    return {
-      module: IntegrationModule,
-      global: true,
-      providers: [...sharedProviders, ...backendProviders],
-      exports: [
-        INTEGRATION_MODULE_OPTIONS,
-        INTEGRATION_MULTI_TENANT,
-        INTEGRATION_FIELD_DIFFER,
-        INTEGRATION_CURSOR_STORE,
-        INTEGRATION_RUN_RECORDER
-      ]
-    };
-  }
-};
-IntegrationModule = __decorateClass([
-  Module({})
-], IntegrationModule);
+  IntegrationModule
+} from "../../../chunk-GCYKMF22.js";
+import {
+  MemoryRunRecorder
+} from "../../../chunk-EO2QPOKH.js";
+import {
+  createLoopbackMiddleware
+} from "../../../chunk-PRWIX6UW.js";
+import {
+  PostgresCursorStore
+} from "../../../chunk-DCCZB4UC.js";
+import {
+  MemoryCursorStore
+} from "../../../chunk-AHV4GDYM.js";
+import {
+  DrizzleIntegrationRunRecorder
+} from "../../../chunk-SR7F3TJY.js";
+import {
+  FieldDiffSchema,
+  FieldDiffValueSchema
+} from "../../../chunk-SQDOBLBP.js";
+import {
+  CURSOR_DIVISIBILITY,
+  CursorStrategySchema,
+  DetectionConfigSchema,
+  FieldMappingSchema,
+  PollDetectionSchema,
+  ResolvedFilterSchema,
+  WebhookDetectionSchema,
+  isDivisibleCursor
+} from "../../../chunk-3NMCDN7L.js";
+import {
+  MemoryEntityChangeSourceRegistry
+} from "../../../chunk-4KNXX6TI.js";
+import {
+  UnknownEntityError
+} from "../../../chunk-3CJFPU6Q.js";
+import {
+  ExecuteIntegrationUseCase
+} from "../../../chunk-OGIZXGPY.js";
+import {
+  MissingTenantIdError,
+  assertTenantId
+} from "../../../chunk-MZ6GV4YF.js";
+import {
+  IncrementalReadBase,
+  mapConcurrent
+} from "../../../chunk-LG57S2SC.js";
+import {
+  integrationRunActionEnum,
+  integrationRunDirectionEnum,
+  integrationRunItemOperationEnum,
+  integrationRunItemStatusEnum,
+  integrationRunItems,
+  integrationRunStatusEnum,
+  integrationRuns,
+  integrationSubscriptions
+} from "../../../chunk-HNWZFNKP.js";
+import {
+  buildChangeSource
+} from "../../../chunk-WWGYCIJX.js";
+import {
+  PollChangeSource
+} from "../../../chunk-4MF3HKJA.js";
+import {
+  WebhookChangeSource
+} from "../../../chunk-YLPAPPLW.js";
+import {
+  DeepEqualDiffer
+} from "../../../chunk-36U5UGIO.js";
+import {
+  ENTITY_CHANGE_SOURCE_REGISTRY,
+  INTEGRATION_CHANGE_SOURCE,
+  INTEGRATION_CURSOR_STORE,
+  INTEGRATION_FIELD_DIFFER,
+  INTEGRATION_MODULE_OPTIONS,
+  INTEGRATION_MULTI_TENANT,
+  INTEGRATION_RUN_RECORDER,
+  INTEGRATION_SINK
+} from "../../../chunk-S7C6TIIF.js";
+import "../../../chunk-U64T4YZE.js";
+import "../../../chunk-2E224ZSN.js";
 export {
   CURSOR_DIVISIBILITY,
   CursorStrategySchema,