@pattern-stack/codegen 0.10.1 → 0.12.0

package/dist/runtime/subsystems/{sync → integration}/index.js

@@ -10,7 +10,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __decorateParam = (index2, decorator) => (target, key) => decorator(target, key, index2);
 
-// runtime/subsystems/sync/sync-field-diff.protocol.ts
+// runtime/subsystems/integration/integration-field-diff.protocol.ts
 import { z } from "zod";
 var FieldDiffValueSchema = z.object({
   from: z.unknown(),
@@ -18,7 +18,38 @@ var FieldDiffValueSchema = z.object({
 });
 var FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);
 
-// runtime/subsystems/sync/detection-config.schema.ts
+// 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),
@@ -76,7 +107,7 @@ var DetectionConfigSchema = z2.discriminatedUnion("mode", [
   WebhookModeSchema
 ]);
 
-// runtime/subsystems/sync/loopback.middleware.ts
+// runtime/subsystems/integration/loopback.middleware.ts
 function createLoopbackMiddleware(store) {
   return (next) => {
     return async function* (subscription, cursor) {
@@ -93,7 +124,7 @@ function createLoopbackMiddleware(store) {
   };
 }
 
-// runtime/subsystems/sync/poll-change-source.ts
+// runtime/subsystems/integration/poll-change-source.ts
 var PollChangeSource = class {
   label;
   adapter;
@@ -183,7 +214,7 @@ var PollChangeSource = class {
   }
 };
 
-// runtime/subsystems/sync/webhook-change-source.ts
+// runtime/subsystems/integration/webhook-change-source.ts
 var WebhookChangeSource = class {
   label;
   queue;
@@ -254,7 +285,7 @@ var WebhookChangeSource = class {
   }
 };
 
-// runtime/subsystems/sync/build-change-source.ts
+// runtime/subsystems/integration/build-change-source.ts
 function buildChangeSource(cfg, fetch, middlewares = []) {
   switch (cfg.mode) {
     case "poll":
@@ -272,21 +303,22 @@ function buildChangeSource(cfg, fetch, middlewares = []) {
   }
 }
 
-// runtime/subsystems/sync/sync.tokens.ts
-var SYNC_CHANGE_SOURCE = "SYNC_CHANGE_SOURCE";
-var SYNC_CURSOR_STORE = "SYNC_CURSOR_STORE";
-var SYNC_FIELD_DIFFER = "SYNC_FIELD_DIFFER";
-var SYNC_SINK = "SYNC_SINK";
-var SYNC_RUN_RECORDER = "SYNC_RUN_RECORDER";
-var SYNC_MODULE_OPTIONS = "SYNC_MODULE_OPTIONS";
-var SYNC_MULTI_TENANT = "SYNC_MULTI_TENANT";
+// 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/sync/sync-errors.ts
+// runtime/subsystems/integration/integration-errors.ts
 var MissingTenantIdError = class extends Error {
   name = "MissingTenantIdError";
   constructor(operation) {
     super(
-      `Missing tenantId for sync operation '${operation}'. SyncModule 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.`
+      `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.`
     );
   }
 };
@@ -297,7 +329,7 @@ function assertTenantId(tenantId, options) {
   }
 }
 
-// runtime/subsystems/sync/sync-audit.schema.ts
+// runtime/subsystems/integration/integration-audit.schema.ts
 import {
   pgEnum,
   pgTable,
@@ -310,39 +342,39 @@ import {
   index,
   uniqueIndex
 } from "drizzle-orm/pg-core";
-var syncRunDirectionEnum = pgEnum("sync_run_direction", [
+var integrationRunDirectionEnum = pgEnum("integration_run_direction", [
   "inbound",
   "outbound"
 ]);
-var syncRunActionEnum = pgEnum("sync_run_action", [
+var integrationRunActionEnum = pgEnum("integration_run_action", [
   "poll",
   "cdc",
   "webhook",
   "manual",
   "writeback"
 ]);
-var syncRunStatusEnum = pgEnum("sync_run_status", [
+var integrationRunStatusEnum = pgEnum("integration_run_status", [
   "running",
   "success",
   "no_changes",
   "failed"
 ]);
-var syncRunItemOperationEnum = pgEnum("sync_run_item_operation", [
+var integrationRunItemOperationEnum = pgEnum("integration_run_item_operation", [
   "created",
   "updated",
   "deleted",
   "noop"
 ]);
-var syncRunItemStatusEnum = pgEnum("sync_run_item_status", [
+var integrationRunItemStatusEnum = pgEnum("integration_run_item_status", [
   "success",
   "failed",
   "skipped"
 ]);
-var syncSubscriptions = pgTable(
-  "sync_subscriptions",
+var integrationSubscriptions = pgTable(
+  "integration_subscriptions",
   {
     id: uuid("id").primaryKey().defaultRandom(),
-    integrationId: text("integration_id").notNull(),
+    connectionId: text("connection_id").notNull(),
     adapter: text("adapter").notNull(),
     domain: text("domain").notNull(),
     externalRef: text("external_ref"),
@@ -357,8 +389,8 @@ var syncSubscriptions = pgTable(
      * successful run advances it.
      */
     cursor: jsonb("cursor").$type(),
-    lastSyncAt: timestamp("last_sync_at", { withTimezone: true }),
-    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    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()
@@ -367,31 +399,31 @@ var syncSubscriptions = pgTable(
     /**
      * 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 `(integration_id, adapter, domain)` and NULL
+     * 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.
      */
-    uqSyncSubscriptionTuple: uniqueIndex("uq_sync_subscriptions_tuple").on(
-      t.integrationId,
+    uqIntegrationSubscriptionTuple: uniqueIndex("uq_integration_subscriptions_tuple").on(
+      t.connectionId,
       t.adapter,
       t.domain,
       t.externalRef
     ),
     /** Scheduling query: list enabled subscriptions ordered by staleness. */
-    idxSyncSubscriptionsEnabledLastSync: index(
-      "idx_sync_subscriptions_enabled_last_sync"
-    ).on(t.enabled, t.lastSyncAt)
+    idxIntegrationSubscriptionsEnabledLastIntegration: index(
+      "idx_integration_subscriptions_enabled_last_integration"
+    ).on(t.enabled, t.lastIntegrationAt)
   })
 );
-var syncRuns = pgTable(
-  "sync_runs",
+var integrationRuns = pgTable(
+  "integration_runs",
   {
     id: uuid("id").primaryKey().defaultRandom(),
-    subscriptionId: uuid("subscription_id").notNull().references(() => syncSubscriptions.id, { onDelete: "cascade" }),
-    direction: syncRunDirectionEnum("direction").notNull(),
-    action: syncRunActionEnum("action").notNull(),
-    status: syncRunStatusEnum("status").notNull().default("running"),
+    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(),
@@ -400,31 +432,31 @@ var syncRuns = pgTable(
     error: text("error"),
     startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
     completedAt: timestamp("completed_at", { withTimezone: true }),
-    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
     tenantId: text("tenant_id")
   },
   (t) => ({
     /** Timeline read: "most recent runs for this subscription". */
-    idxSyncRunsSubscriptionStartedAt: index(
-      "idx_sync_runs_subscription_started_at"
+    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". */
-    idxSyncRunsStatusStartedAt: index("idx_sync_runs_status_started_at").on(
+    idxIntegrationRunsStatusStartedAt: index("idx_integration_runs_status_started_at").on(
       t.status,
       t.startedAt
     )
   })
 );
-var syncRunItems = pgTable(
-  "sync_run_items",
+var integrationRunItems = pgTable(
+  "integration_run_items",
   {
     id: uuid("id").primaryKey().defaultRandom(),
-    syncRunId: uuid("sync_run_id").notNull().references(() => syncRuns.id, { onDelete: "cascade" }),
+    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: syncRunItemOperationEnum("operation").notNull(),
-    status: syncRunItemStatusEnum("status").notNull(),
+    operation: integrationRunItemOperationEnum("operation").notNull(),
+    status: integrationRunItemStatusEnum("status").notNull(),
     /**
      * Structured per-field diff — ADR-0003 shape enforced by
      * `FieldDiffSchema.parse` at the recorder service layer.
@@ -438,23 +470,23 @@ var syncRunItems = pgTable(
     title: text("title"),
     error: text("error"),
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    /** Runtime-enforced when `SYNC_MULTI_TENANT` is true; see SYNC-6. */
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
     tenantId: text("tenant_id")
   },
   (t) => ({
     /** Ordered timeline within a run. */
-    idxSyncRunItemsRunCreatedAt: index("idx_sync_run_items_run_created_at").on(
-      t.syncRunId,
+    idxIntegrationRunItemsRunCreatedAt: index("idx_integration_run_items_run_created_at").on(
+      t.integrationRunId,
       t.createdAt
     ),
-    /** Per-record history: "every sync that touched opportunity/$extId". */
-    idxSyncRunItemsEntityExternal: index(
-      "idx_sync_run_items_entity_external"
+    /** Per-record history: "every integration that touched opportunity/$extId". */
+    idxIntegrationRunItemsEntityExternal: index(
+      "idx_integration_run_items_entity_external"
     ).on(t.entityType, t.externalId)
   })
 );
 
-// runtime/subsystems/sync/sync-cursor-store.memory-backend.ts
+// runtime/subsystems/integration/integration-cursor-store.memory-backend.ts
 import { Injectable } from "@nestjs/common";
 var MemoryCursorStore = class {
   /**
@@ -465,7 +497,7 @@ var MemoryCursorStore = class {
   /**
    * Seedable subscription metadata for `listAll` — the memory backend
    * stores only `subscriptionId → cursor` in its write path, so the
-   * snapshot shape (`integrationId`, `adapter`, `domain`, `externalRef`,
+   * 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
@@ -485,12 +517,12 @@ var MemoryCursorStore = class {
       const meta = this.subscriptions.get(subscriptionId);
       snapshots.push({
         subscriptionId,
-        integrationId: meta?.integrationId ?? "",
+        connectionId: meta?.connectionId ?? "",
         adapter: meta?.adapter ?? "",
         domain: meta?.domain ?? "",
         externalRef: meta?.externalRef ?? null,
         cursor: cursor ?? null,
-        lastSyncAt: meta?.lastSyncAt ?? null,
+        lastIntegrationAt: meta?.lastIntegrationAt ?? null,
         updatedAt: meta?.updatedAt ?? /* @__PURE__ */ new Date(0),
         tenantId: null
       });
@@ -509,7 +541,7 @@ MemoryCursorStore = __decorateClass([
   Injectable()
 ], MemoryCursorStore);
 
-// runtime/subsystems/sync/sync-run-recorder.memory-backend.ts
+// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
 import { Injectable as Injectable2 } from "@nestjs/common";
 var MemoryRunRecorder = class {
   /**
@@ -518,14 +550,14 @@ var MemoryRunRecorder = class {
    */
   runs = /* @__PURE__ */ new Map();
   /**
-   * Items keyed by `sync_run_id`, array order matches insertion order —
-   * mirrors the timeline the `(sync_run_id, created_at)` index produces
+   * 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 `integrationId` values. The memory
+   * `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.
@@ -554,10 +586,10 @@ var MemoryRunRecorder = class {
   }
   async recordItem(input) {
     FieldDiffSchema.parse(input.changedFields);
-    const bucket = this.items.get(input.syncRunId);
+    const bucket = this.items.get(input.integrationRunId);
     if (!bucket) {
       throw new Error(
-        `MemoryRunRecorder.recordItem: no run started for id '${input.syncRunId}'. Call startRun(...) first.`
+        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. Call startRun(...) first.`
       );
     }
     bucket.push(input);
@@ -583,10 +615,10 @@ var MemoryRunRecorder = class {
     return filtered.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit).map((r) => ({
       id: r.id,
       subscriptionId: r.subscriptionId,
-      // integrationId is only knowable if the test seeded subscriptions
+      // 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.
-      integrationId: this.subscriptions.get(r.subscriptionId)?.integrationId ?? "",
+      connectionId: this.subscriptions.get(r.subscriptionId)?.connectionId ?? "",
       status: r.status,
       startedAt: r.startedAt,
       completedAt: r.completedAt,
@@ -614,7 +646,7 @@ MemoryRunRecorder = __decorateClass([
   Injectable2()
 ], MemoryRunRecorder);
 
-// runtime/subsystems/sync/deep-equal.differ.ts
+// runtime/subsystems/integration/deep-equal.differ.ts
 import { Injectable as Injectable3 } from "@nestjs/common";
 var DEFAULT_IGNORE_FIELDS = /* @__PURE__ */ new Set([
   "id",
@@ -713,9 +745,9 @@ function deepEqualObject(a, b) {
   return true;
 }
 
-// runtime/subsystems/sync/execute-sync.use-case.ts
+// runtime/subsystems/integration/execute-integration.use-case.ts
 import { Inject, Injectable as Injectable4, Logger, Optional } from "@nestjs/common";
-var ExecuteSyncUseCase = class {
+var ExecuteIntegrationUseCase = class {
   constructor(source, cursors, differ, sink, recorder, multiTenant = false) {
     this.source = source;
     this.cursors = cursors;
@@ -730,7 +762,7 @@ var ExecuteSyncUseCase = class {
   sink;
   recorder;
   multiTenant;
-  logger = new Logger(ExecuteSyncUseCase.name);
+  logger = new Logger(ExecuteIntegrationUseCase.name);
   async execute(input) {
     assertTenantId(input.tenantId, {
       multiTenant: this.multiTenant,
@@ -765,10 +797,10 @@ var ExecuteSyncUseCase = class {
           recordsFailed++;
           const message = err instanceof Error ? err.message : String(err);
           this.logger.warn(
-            `sync item failed: subscription=${input.subscription.id} externalId=${change.externalId}: ${message}`
+            `integration item failed: subscription=${input.subscription.id} externalId=${change.externalId}: ${message}`
           );
           await this.recorder.recordItem({
-            syncRunId: runId,
+            integrationRunId: runId,
             entityType: input.subscription.domain,
             externalId: change.externalId,
             operation: change.operation === "deleted" ? "deleted" : "updated",
@@ -791,7 +823,7 @@ var ExecuteSyncUseCase = class {
       status = "failed";
       runError = err instanceof Error ? err.message : String(err);
       this.logger.error(
-        `sync source failed: subscription=${input.subscription.id}: ${runError}`
+        `integration source failed: subscription=${input.subscription.id}: ${runError}`
       );
     }
     if (cursorAdvanced && latestCursor !== null && latestCursor !== void 0) {
@@ -836,7 +868,7 @@ var ExecuteSyncUseCase = class {
         change.externalId
       );
       await this.recorder.recordItem({
-        syncRunId: runId,
+        integrationRunId: runId,
         entityType: input.subscription.domain,
         externalId: change.externalId,
         localId: result?.id ?? null,
@@ -859,7 +891,7 @@ var ExecuteSyncUseCase = class {
     if (diff === "noop") {
       if (!this.sink.reprojectsOnNoop) {
         await this.recorder.recordItem({
-          syncRunId: runId,
+          integrationRunId: runId,
           entityType: input.subscription.domain,
           externalId: change.externalId,
           localId: null,
@@ -876,7 +908,7 @@ var ExecuteSyncUseCase = class {
         input.provider
       );
       await this.recorder.recordItem({
-        syncRunId: runId,
+        integrationRunId: runId,
         entityType: input.subscription.domain,
         externalId: change.externalId,
         localId: noopLocalId,
@@ -893,7 +925,7 @@ var ExecuteSyncUseCase = class {
       input.provider
     );
     await this.recorder.recordItem({
-      syncRunId: runId,
+      integrationRunId: runId,
       entityType: input.subscription.domain,
       externalId: change.externalId,
       localId,
@@ -904,25 +936,25 @@ var ExecuteSyncUseCase = class {
     });
   }
 };
-ExecuteSyncUseCase = __decorateClass([
+ExecuteIntegrationUseCase = __decorateClass([
   Injectable4(),
-  __decorateParam(0, Inject(SYNC_CHANGE_SOURCE)),
-  __decorateParam(1, Inject(SYNC_CURSOR_STORE)),
-  __decorateParam(2, Inject(SYNC_FIELD_DIFFER)),
-  __decorateParam(3, Inject(SYNC_SINK)),
-  __decorateParam(4, Inject(SYNC_RUN_RECORDER)),
+  __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(SYNC_MULTI_TENANT))
-], ExecuteSyncUseCase);
+  __decorateParam(5, Inject(INTEGRATION_MULTI_TENANT))
+], ExecuteIntegrationUseCase);
 
-// runtime/subsystems/sync/sync-cursor-store.drizzle-backend.ts
+// 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/sync/sync-cursor-store.drizzle-backend.ts
+// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
 var PostgresCursorStore = class {
   constructor(db, multiTenant) {
     this.db = db;
@@ -932,15 +964,15 @@ var PostgresCursorStore = class {
   multiTenant;
   async get(subscriptionId, tenantId) {
     const where = this.buildWhere(subscriptionId, tenantId, "cursor.get");
-    const rows = await this.db.select({ cursor: syncSubscriptions.cursor }).from(syncSubscriptions).where(where).limit(1);
+    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(syncSubscriptions).set({
+    await this.db.update(integrationSubscriptions).set({
       cursor,
-      lastSyncAt: /* @__PURE__ */ new Date(),
+      lastIntegrationAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
     }).where(where);
   }
@@ -949,26 +981,26 @@ var PostgresCursorStore = class {
       multiTenant: this.multiTenant,
       operation: "cursor.listAll"
     });
-    const where = this.multiTenant ? eq(syncSubscriptions.tenantId, tenantId) : void 0;
+    const where = this.multiTenant ? eq(integrationSubscriptions.tenantId, tenantId) : void 0;
     const rows = await this.db.select({
-      id: syncSubscriptions.id,
-      integrationId: syncSubscriptions.integrationId,
-      adapter: syncSubscriptions.adapter,
-      domain: syncSubscriptions.domain,
-      externalRef: syncSubscriptions.externalRef,
-      cursor: syncSubscriptions.cursor,
-      lastSyncAt: syncSubscriptions.lastSyncAt,
-      updatedAt: syncSubscriptions.updatedAt,
-      tenantId: syncSubscriptions.tenantId
-    }).from(syncSubscriptions).where(where).orderBy(desc(syncSubscriptions.updatedAt));
+      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,
-      integrationId: row.integrationId,
+      connectionId: row.connectionId,
       adapter: row.adapter,
       domain: row.domain,
       externalRef: row.externalRef,
       cursor: row.cursor ?? null,
-      lastSyncAt: row.lastSyncAt,
+      lastIntegrationAt: row.lastIntegrationAt,
       updatedAt: row.updatedAt,
       tenantId: row.tenantId
     }));
@@ -985,24 +1017,24 @@ var PostgresCursorStore = class {
     });
     if (this.multiTenant) {
       return and(
-        eq(syncSubscriptions.id, subscriptionId),
-        eq(syncSubscriptions.tenantId, tenantId)
+        eq(integrationSubscriptions.id, subscriptionId),
+        eq(integrationSubscriptions.tenantId, tenantId)
       );
     }
-    return eq(syncSubscriptions.id, subscriptionId);
+    return eq(integrationSubscriptions.id, subscriptionId);
   }
 };
 PostgresCursorStore = __decorateClass([
   Injectable5(),
   __decorateParam(0, Inject2(DRIZZLE)),
   __decorateParam(1, Optional2()),
-  __decorateParam(1, Inject2(SYNC_MULTI_TENANT))
+  __decorateParam(1, Inject2(INTEGRATION_MULTI_TENANT))
 ], PostgresCursorStore);
 
-// runtime/subsystems/sync/sync-run-recorder.drizzle-backend.ts
+// 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 DrizzleSyncRunRecorder = class {
+var DrizzleIntegrationRunRecorder = class {
   constructor(db, multiTenant) {
     this.db = db;
     this.multiTenant = multiTenant ?? false;
@@ -1014,17 +1046,17 @@ var DrizzleSyncRunRecorder = class {
       multiTenant: this.multiTenant,
       operation: "startRun"
     });
-    const rows = await this.db.insert(syncRuns).values({
+    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: syncRuns.id });
+    }).returning({ id: integrationRuns.id });
     const id = rows[0]?.id;
     if (!id) {
-      throw new Error("DrizzleSyncRunRecorder: INSERT RETURNING produced no id");
+      throw new Error("DrizzleIntegrationRunRecorder: INSERT RETURNING produced no id");
     }
     return { id };
   }
@@ -1034,8 +1066,8 @@ var DrizzleSyncRunRecorder = class {
       operation: "recordItem"
     });
     FieldDiffSchema.parse(input.changedFields);
-    await this.db.insert(syncRunItems).values({
-      syncRunId: input.syncRunId,
+    await this.db.insert(integrationRunItems).values({
+      integrationRunId: input.integrationRunId,
       entityType: input.entityType,
       externalId: input.externalId,
       localId: input.localId ?? null,
@@ -1054,29 +1086,29 @@ var DrizzleSyncRunRecorder = class {
     });
     const conditions = [];
     if (subscriptionId !== void 0) {
-      conditions.push(eq2(syncRuns.subscriptionId, subscriptionId));
+      conditions.push(eq2(integrationRuns.subscriptionId, subscriptionId));
     }
     if (this.multiTenant) {
-      conditions.push(eq2(syncRuns.tenantId, tenantId));
+      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: syncRuns.id,
-      subscriptionId: syncRuns.subscriptionId,
-      integrationId: syncSubscriptions.integrationId,
-      status: syncRuns.status,
-      startedAt: syncRuns.startedAt,
-      completedAt: syncRuns.completedAt,
-      recordsProcessed: syncRuns.recordsProcessed,
-      tenantId: syncRuns.tenantId
-    }).from(syncRuns).innerJoin(
-      syncSubscriptions,
-      eq2(syncRuns.subscriptionId, syncSubscriptions.id)
-    ).where(where).orderBy(desc2(syncRuns.startedAt)).limit(limit);
+      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,
-      integrationId: row.integrationId,
+      connectionId: row.connectionId,
       status: row.status,
       startedAt: row.startedAt,
       completedAt: row.completedAt,
@@ -1085,7 +1117,7 @@ var DrizzleSyncRunRecorder = class {
     }));
   }
   async completeRun(runId, input) {
-    await this.db.update(syncRuns).set({
+    await this.db.update(integrationRuns).set({
       status: input.status,
       recordsFound: input.recordsFound,
       recordsProcessed: input.recordsProcessed,
@@ -1093,27 +1125,27 @@ var DrizzleSyncRunRecorder = class {
       durationMs: input.durationMs,
       error: input.error ?? null,
       completedAt: /* @__PURE__ */ new Date()
-    }).where(eq2(syncRuns.id, runId));
+    }).where(eq2(integrationRuns.id, runId));
   }
 };
-DrizzleSyncRunRecorder = __decorateClass([
+DrizzleIntegrationRunRecorder = __decorateClass([
   Injectable6(),
   __decorateParam(0, Inject3(DRIZZLE)),
   __decorateParam(1, Optional3()),
-  __decorateParam(1, Inject3(SYNC_MULTI_TENANT))
-], DrizzleSyncRunRecorder);
+  __decorateParam(1, Inject3(INTEGRATION_MULTI_TENANT))
+], DrizzleIntegrationRunRecorder);
 
-// runtime/subsystems/sync/sync.module.ts
+// runtime/subsystems/integration/integration.module.ts
 import { Module } from "@nestjs/common";
-var SyncModule = class {
+var IntegrationModule = class {
   static forRoot(options) {
     const multiTenant = options.multiTenant ?? false;
     const sharedProviders = [
-      { provide: SYNC_MODULE_OPTIONS, useValue: options },
-      { provide: SYNC_MULTI_TENANT, useValue: multiTenant },
+      { provide: INTEGRATION_MODULE_OPTIONS, useValue: options },
+      { provide: INTEGRATION_MULTI_TENANT, useValue: multiTenant },
       // Default differ — consumers can override by binding a different
-      // `IFieldDiffer<T>` to `SYNC_FIELD_DIFFER` in their feature module.
-      { provide: SYNC_FIELD_DIFFER, useValue: new DeepEqualDiffer() }
+      // `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
@@ -1121,74 +1153,77 @@ var SyncModule = class {
       // direct assertions. Matches JOB-4 / MemoryJobStore shape.
       { provide: MemoryCursorStore, useValue: new MemoryCursorStore() },
       {
-        provide: SYNC_CURSOR_STORE,
+        provide: INTEGRATION_CURSOR_STORE,
         useExisting: MemoryCursorStore
       },
       { provide: MemoryRunRecorder, useValue: new MemoryRunRecorder() },
       {
-        provide: SYNC_RUN_RECORDER,
+        provide: INTEGRATION_RUN_RECORDER,
         useExisting: MemoryRunRecorder
       }
     ] : [
       // Drizzle backends — injected with DRIZZLE (provided by the
-      // consumer's DrizzleModule) + the SYNC_MULTI_TENANT flag
+      // consumer's DrizzleModule) + the INTEGRATION_MULTI_TENANT flag
       // we bound above.
-      { provide: SYNC_CURSOR_STORE, useClass: PostgresCursorStore },
-      { provide: SYNC_RUN_RECORDER, useClass: DrizzleSyncRunRecorder }
+      { provide: INTEGRATION_CURSOR_STORE, useClass: PostgresCursorStore },
+      { provide: INTEGRATION_RUN_RECORDER, useClass: DrizzleIntegrationRunRecorder }
     ];
     return {
-      module: SyncModule,
+      module: IntegrationModule,
       global: true,
       providers: [...sharedProviders, ...backendProviders],
       exports: [
-        SYNC_MODULE_OPTIONS,
-        SYNC_MULTI_TENANT,
-        SYNC_FIELD_DIFFER,
-        SYNC_CURSOR_STORE,
-        SYNC_RUN_RECORDER
+        INTEGRATION_MODULE_OPTIONS,
+        INTEGRATION_MULTI_TENANT,
+        INTEGRATION_FIELD_DIFFER,
+        INTEGRATION_CURSOR_STORE,
+        INTEGRATION_RUN_RECORDER
       ]
     };
   }
 };
-SyncModule = __decorateClass([
+IntegrationModule = __decorateClass([
   Module({})
-], SyncModule);
+], IntegrationModule);
 export {
   CursorStrategySchema,
   DeepEqualDiffer,
   DetectionConfigSchema,
-  DrizzleSyncRunRecorder,
-  ExecuteSyncUseCase,
+  DrizzleIntegrationRunRecorder,
+  ENTITY_CHANGE_SOURCE_REGISTRY,
+  ExecuteIntegrationUseCase,
   FieldDiffSchema,
   FieldDiffValueSchema,
   FieldMappingSchema,
+  INTEGRATION_CHANGE_SOURCE,
+  INTEGRATION_CURSOR_STORE,
+  INTEGRATION_FIELD_DIFFER,
+  INTEGRATION_MODULE_OPTIONS,
+  INTEGRATION_MULTI_TENANT,
+  INTEGRATION_RUN_RECORDER,
+  INTEGRATION_SINK,
+  IntegrationModule,
   MemoryCursorStore,
+  MemoryEntityChangeSourceRegistry,
   MemoryRunRecorder,
   MissingTenantIdError,
   PollChangeSource,
   PollDetectionSchema,
   PostgresCursorStore,
   ResolvedFilterSchema,
-  SYNC_CHANGE_SOURCE,
-  SYNC_CURSOR_STORE,
-  SYNC_FIELD_DIFFER,
-  SYNC_MODULE_OPTIONS,
-  SYNC_MULTI_TENANT,
-  SYNC_RUN_RECORDER,
-  SYNC_SINK,
-  SyncModule,
+  UnknownEntityError,
   WebhookChangeSource,
   WebhookDetectionSchema,
   assertTenantId,
   buildChangeSource,
   createLoopbackMiddleware,
-  syncRunActionEnum,
-  syncRunDirectionEnum,
-  syncRunItemOperationEnum,
-  syncRunItemStatusEnum,
-  syncRunItems,
-  syncRunStatusEnum,
-  syncRuns,
-  syncSubscriptions
+  integrationRunActionEnum,
+  integrationRunDirectionEnum,
+  integrationRunItemOperationEnum,
+  integrationRunItemStatusEnum,
+  integrationRunItems,
+  integrationRunStatusEnum,
+  integrationRuns,
+  integrationSubscriptions
 };
 //# sourceMappingURL=index.js.map