@pattern-stack/codegen 0.10.1 → 0.12.0

package/dist/src/index.js

@@ -43,7 +43,7 @@ import { parse as parseYaml } from "yaml";
 // src/schema/entity-definition.schema.ts
 import { z as z3 } from "zod";
 
-// 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(),
@@ -51,7 +51,7 @@ var FieldDiffValueSchema = z.object({
 });
 var FieldDiffSchema = z.record(z.string(), FieldDiffValueSchema);
 
-// runtime/subsystems/sync/detection-config.schema.ts
+// runtime/subsystems/integration/detection-config.schema.ts
 import { z as z2 } from "zod";
 var FieldMappingSchema = z2.object({
   source: z2.string().min(1),
@@ -109,21 +109,21 @@ var DetectionConfigSchema = z2.discriminatedUnion("mode", [
   WebhookModeSchema
 ]);
 
-// 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";
 
-// 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.`
     );
   }
 };
@@ -134,7 +134,7 @@ function assertTenantId(tenantId, options) {
   }
 }
 
-// runtime/subsystems/sync/sync-audit.schema.ts
+// runtime/subsystems/integration/integration-audit.schema.ts
 import {
   pgEnum,
   pgTable,
@@ -147,39 +147,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"),
@@ -194,8 +194,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()
@@ -204,31 +204,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(),
@@ -237,31 +237,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.
@@ -275,23 +275,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 {
   /**
@@ -302,7 +302,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
@@ -322,12 +322,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
       });
@@ -346,7 +346,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 {
   /**
@@ -355,14 +355,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.
@@ -391,10 +391,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);
@@ -420,10 +420,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,
@@ -451,7 +451,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",
@@ -550,9 +550,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;
@@ -567,7 +567,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,
@@ -602,10 +602,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",
@@ -628,7 +628,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) {
@@ -673,7 +673,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,
@@ -696,7 +696,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,
@@ -713,7 +713,7 @@ var ExecuteSyncUseCase = class {
         input.provider
       );
       await this.recorder.recordItem({
-        syncRunId: runId,
+        integrationRunId: runId,
         entityType: input.subscription.domain,
         externalId: change.externalId,
         localId: noopLocalId,
@@ -730,7 +730,7 @@ var ExecuteSyncUseCase = class {
       input.provider
     );
     await this.recorder.recordItem({
-      syncRunId: runId,
+      integrationRunId: runId,
       entityType: input.subscription.domain,
       externalId: change.externalId,
       localId,
@@ -741,25 +741,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;
@@ -769,15 +769,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);
   }
@@ -786,26 +786,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
     }));
@@ -822,24 +822,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;
@@ -851,17 +851,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 };
   }
@@ -871,8 +871,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,
@@ -891,29 +891,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,
@@ -922,7 +922,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,
@@ -930,27 +930,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
@@ -958,38 +958,38 @@ 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);
 
 // src/schema/entity-definition.schema.ts
 var FieldTypeSchema = z3.enum([
@@ -1297,21 +1297,21 @@ var AnyQueryDeclarationSchema = z3.union([
   SearchQueryDeclarationSchema,
   QueryDeclarationSchema
 ]);
-var SyncDirectionSchema = z3.enum([
+var IntegrationDirectionSchema = z3.enum([
   "inbound",
   "outbound",
   "bidirectional"
 ]);
-var ProviderSyncSchema = z3.object({
+var ProviderIntegrationSchema = z3.object({
   remote_entity: z3.string(),
-  direction: SyncDirectionSchema,
+  direction: IntegrationDirectionSchema,
   cdc: z3.boolean().optional().default(false),
   field_mapping: z3.record(z3.string(), z3.string()).optional(),
   read_only_fields: z3.array(z3.string()).optional()
 });
-var SyncConfigSchema = z3.object({
+var IntegrationConfigSchema = z3.object({
   electric: z3.boolean().optional().default(false),
-  providers: z3.record(z3.string(), ProviderSyncSchema).optional()
+  providers: z3.record(z3.string(), ProviderIntegrationSchema).optional()
 });
 var EventDeclarationSchema = z3.object({
   name: z3.string().regex(/^[a-z][a-z0-9_]*$/, "Event name must be snake_case"),
@@ -1411,22 +1411,52 @@ var EntityDefinitionSchema = z3.object({
   // v2: Declarative query generation (ADR-005)
   // Generates repository + service + use case methods from declarations
   queries: z3.array(AnyQueryDeclarationSchema).optional(),
-  // v2: Integration sync configuration (CODEGEN-EVOLUTION-PLAN Phase 2)
-  // Electric SQL + provider sync (Salesforce, HubSpot, etc.)
-  sync: SyncConfigSchema.optional(),
+  // v2: Integration integration configuration (CODEGEN-EVOLUTION-PLAN Phase 2)
+  // Electric SQL + provider integration (Salesforce, HubSpot, etc.)
+  integration: IntegrationConfigSchema.optional(),
   // ADR-033.1: Provider-keyed change-source detection.
   //
   // Map of provider name → DetectionConfig. Single-provider entities use
   // a one-key map; multi-provider entities list each provider as a
   // separate key. Each value is an independent `DetectionConfig` (its
   // own mode/cursor/mapping/filters) sourced from the canonical schema
-  // in `runtime/subsystems/sync` so this validator and the runtime
+  // in `runtime/subsystems/integration` so this validator and the runtime
   // parser stay in lockstep.
   //
   // Within-file cross-check (ADR-033.1 §6): every key here must also
-  // appear in `sync.providers` — see the superRefine on
+  // appear in `integration.providers` — see the superRefine on
   // `EntityDefinitionSchema` below.
   detection: z3.record(z3.string(), DetectionConfigSchema).optional(),
+  // RFC-0001 §1/§8: the integration *surface* this entity belongs to
+  // (e.g. 'calendar', 'mail', 'crm'). Surfaces span provider contexts
+  // (ADR-0006) — one Google OAuth feeds calendar+mail+transcript. The union
+  // of `surface:` values across all entity YAML is the closed set that a
+  // provider's `surfaces:` must be a subset of (cross-checked in
+  // src/parser/validate-providers.ts). Optional: entities without an
+  // integration surface omit it. The surface-package *emission* convention
+  // is Track C (#329); this field is only the declarative input both tracks
+  // read.
+  surface: z3.string().optional(),
+  // Bounded-context declaration (ADR-0004) — "which bounded context this
+  // entity belongs to". This is the DURABLE decision; it is a plain
+  // bounded-context slug, NOT a folder knob. Different features consume it:
+  //
+  //   - #403 (this PR, the FIRST consumer): drives the generated code's
+  //     module output folder. clean-lite-ps nests the entity's module under
+  //     `<modules>/<context>/<entity>/` so same-context entities group
+  //     together; untagged entities stay flat (`<modules>/<entity>/`).
+  //   - ADR-0004 (deferred): a later `naming: prefix | schema` knob reads
+  //     this SAME field to drive the Postgres physical layout —
+  //     `prefix` → `pgTable('<context>__<table>')`, then the flip to
+  //     `schema` → `pgSchema('<context>').table('<table>')`. NOT wired here;
+  //     #403 makes no table/column/schema changes.
+  //
+  // Sibling to `surface:` and orthogonal to it (ADR-0006): context = model
+  // cohesion (which domain), surface = vendor composition (which integration).
+  context: z3.string().regex(
+    /^[a-z][a-z0-9_]*$/,
+    "context must be lowercase snake_case (e.g. 'integration')"
+  ).optional(),
   // v2: Domain event declarations (CODEGEN-EVOLUTION-PLAN Phase 2)
   // Generates typed event classes, handlers, and queue registration
   events: z3.array(EventDeclarationSchema).optional(),
@@ -1445,7 +1475,18 @@ var EntityDefinitionSchema = z3.object({
   ).optional(),
   // v2: Analytics / semantic layer configuration
   // Cube.js measure packs, custom cube name, and metric definitions
-  analytics: AnalyticsBlockSchema.optional()
+  analytics: AnalyticsBlockSchema.optional(),
+  // Composite (multi-column) unique indexes (#356). Single-column uniqueness
+  // is `unique: true` on the field itself; this declares constraints that
+  // span 2+ columns, e.g. UNIQUE (conversation_id, sequence). Emitted as a
+  // `uniqueIndex(...).on(...)` entry in the generated entity's pgTable
+  // extra-config callback. `name` defaults to <table>_<col1>_<col2>_uniq.
+  unique_indexes: z3.array(
+    z3.object({
+      fields: z3.array(z3.string()).min(2, "unique_indexes entries span 2+ columns \u2014 use `unique: true` on the field for single-column uniqueness"),
+      name: z3.string().optional()
+    }).strict()
+  ).optional()
 }).strict().refine(
   (data) => !data.eav_value_table || typeof data.eav_definition_table === "string",
   {
@@ -1454,13 +1495,13 @@ var EntityDefinitionSchema = z3.object({
   }
 ).superRefine((entity, ctx) => {
   if (!entity.detection) return;
-  const declared = new Set(Object.keys(entity.sync?.providers ?? {}));
+  const declared = new Set(Object.keys(entity.integration?.providers ?? {}));
   for (const provider of Object.keys(entity.detection)) {
     if (!declared.has(provider)) {
       ctx.addIssue({
         code: "custom",
         path: ["detection", provider],
-        message: `Provider '${provider}' used in detection: but not declared in sync.providers. Known providers: ${[...declared].join(", ")}`
+        message: `Provider '${provider}' used in detection: but not declared in integration.providers. Known providers: ${[...declared].join(", ")}`
       });
     }
   }
@@ -1882,6 +1923,56 @@ function safeValidateJunctionDefinition(data) {
   return { success: false, error: result.error };
 }
 
+// src/schema/provider-definition.schema.ts
+import { z as z7 } from "zod";
+var IMPORT_REF_RE = /^[^#\s]+#[A-Za-z_$][A-Za-z0-9_$]*$/;
+var ImportRefSchema = z7.string().regex(
+  IMPORT_REF_RE,
+  "must be an 'import-path#Export' reference (e.g. '@app/foo/bar.strategy#BarStrategy')"
+);
+var AuthTypeSchema = z7.enum(["oauth2", "api-key", "app-password"]);
+var AuthSchema = z7.object({
+  type: AuthTypeSchema,
+  // Class implementing the auth subsystem's strategy contract (ADR-031).
+  // Pre-flight verified against a real export at codegen time.
+  strategy: ImportRefSchema,
+  // Required (and non-empty) iff type === 'oauth2'; see refine below.
+  scopes: z7.array(z7.string()).optional()
+}).strict().refine(
+  (a) => a.type !== "oauth2" || a.scopes !== void 0 && a.scopes.length > 0,
+  {
+    message: "auth.scopes is required and must be non-empty when auth.type is 'oauth2'",
+    path: ["scopes"]
+  }
+);
+var ClientSchema = z7.object({
+  // API client class. Pre-flight verified against a real export.
+  class: ImportRefSchema,
+  base_url: z7.string().url("client.base_url must be an absolute URL")
+}).strict();
+var ProviderDefinitionSchema = z7.object({
+  // Provider id — the canonical string used as detection: keys, audit rows,
+  // subscription rows. kebab/lower; unique across definitions/providers/
+  // (uniqueness is a cross-file check in validate-providers.ts).
+  slug: z7.string().regex(
+    /^[a-z][a-z0-9-]*$/,
+    "slug must be kebab-case lower (e.g. 'google', 'hubspot')"
+  ),
+  display_name: z7.string().optional(),
+  auth: AuthSchema,
+  client: ClientSchema,
+  // Surfaces this provider serves (ADR-0006: surfaces span contexts — one
+  // Google OAuth feeds calendar+mail+transcript). Each must reference a real
+  // `surface:` declared on some entity; that cross-check is in
+  // validate-providers.ts. Non-empty enforced here.
+  surfaces: z7.array(z7.string()).min(1, "surfaces must list at least one surface"),
+  // Optional auth lifecycle hints consumed by provider-module emission (D2).
+  // `refresh_behavior` is left as a free string in D1 — its domain firms up
+  // when D2 consumes it; carrying it now keeps the YAML lossless.
+  token_lifetime: z7.number().int().positive().optional(),
+  refresh_behavior: z7.string().optional()
+}).strict();
+
 // src/utils/yaml-loader.ts
 function loadEntityFromYaml(filePath) {
   if (!existsSync(filePath)) {
@@ -2094,14 +2185,14 @@ function transformToEntity(result) {
       entity.relationships.set(name, relationship);
     }
   }
-  if (definition.sync) {
-    const syncDef = definition.sync;
-    const parsedSync = {
-      electric: syncDef.electric ?? false
+  if (definition.integration) {
+    const integrationDef = definition.integration;
+    const parsedIntegration = {
+      electric: integrationDef.electric ?? false
     };
-    if (syncDef.providers) {
-      parsedSync.providers = {};
-      for (const [providerName, providerDef] of Object.entries(syncDef.providers)) {
+    if (integrationDef.providers) {
+      parsedIntegration.providers = {};
+      for (const [providerName, providerDef] of Object.entries(integrationDef.providers)) {
         const parsedProvider = {
           remoteEntity: providerDef.remote_entity,
           direction: providerDef.direction,
@@ -2113,10 +2204,10 @@ function transformToEntity(result) {
         if (providerDef.read_only_fields) {
           parsedProvider.readOnlyFields = providerDef.read_only_fields;
         }
-        parsedSync.providers[providerName] = parsedProvider;
+        parsedIntegration.providers[providerName] = parsedProvider;
       }
     }
-    entity.sync = parsedSync;
+    entity.integration = parsedIntegration;
   }
   if (definition.events) {
     entity.events = definition.events.map((ev) => ({
@@ -2389,6 +2480,11 @@ function resolveRelationshipReferences(relationshipDefs, entities) {
   return issues;
 }
 
+// src/parser/validate-providers.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { isAbsolute, join as join2, resolve as resolve3 } from "path";
+import ts from "typescript";
+
 // src/analyzer/graph-builder.ts
 function inferCardinality(type) {
   switch (type) {
@@ -2770,8 +2866,8 @@ function checkConsistency(graph) {
     if (entity.queries !== void 0) {
       issues.push(...checkQueryFieldReferences(entity));
     }
-    if (entity.sync !== void 0) {
-      issues.push(...checkSyncFieldMappingReferences(entity));
+    if (entity.integration !== void 0) {
+      issues.push(...checkIntegrationFieldMappingReferences(entity));
       issues.push(...checkExternalIdTrackingCollision(entity));
     }
   }
@@ -3007,19 +3103,19 @@ function checkQueryFieldReferences(entity) {
   }
   return issues;
 }
-function checkSyncFieldMappingReferences(entity) {
+function checkIntegrationFieldMappingReferences(entity) {
   const issues = [];
   const availableFields = getAvailableFieldNames(entity);
   const availableSet = new Set(availableFields);
-  for (const [providerName, provider] of Object.entries(entity.sync?.providers ?? {})) {
+  for (const [providerName, provider] of Object.entries(entity.integration?.providers ?? {})) {
     for (const fieldName of Object.keys(provider.fieldMapping ?? {})) {
       if (!availableSet.has(fieldName)) {
         issues.push({
           severity: "warning",
-          type: "unknown_sync_field_mapping",
+          type: "unknown_integration_field_mapping",
           entity: entity.name,
           field: fieldName,
-          message: `Sync field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
+          message: `Integration field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
         });
       }
     }
@@ -3027,10 +3123,10 @@ function checkSyncFieldMappingReferences(entity) {
       if (!availableSet.has(fieldName)) {
         issues.push({
           severity: "warning",
-          type: "unknown_sync_field_mapping",
+          type: "unknown_integration_field_mapping",
           entity: entity.name,
           field: fieldName,
-          message: `Sync field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
+          message: `Integration field mapping references unknown field "${fieldName}" for provider "${providerName}" in entity "${entity.name}"`
         });
       }
     }
@@ -3041,14 +3137,14 @@ function checkExternalIdTrackingCollision(entity) {
   const issues = [];
   const hasExternalIdTracking = entity.behaviors.includes("external_id_tracking");
   if (!hasExternalIdTracking) return issues;
-  for (const [providerName, provider] of Object.entries(entity.sync?.providers ?? {})) {
+  for (const [providerName, provider] of Object.entries(entity.integration?.providers ?? {})) {
     if (provider.fieldMapping && "external_id" in provider.fieldMapping) {
       issues.push({
         severity: "warning",
         type: "external_id_tracking_collision",
         entity: entity.name,
         field: "external_id",
-        message: `Entity "${entity.name}" has external_id_tracking behavior and also maps "external_id" in sync field_mapping for provider "${providerName}". The behavior-added field may collide with the mapped field.`
+        message: `Entity "${entity.name}" has external_id_tracking behavior and also maps "external_id" in integration field_mapping for provider "${providerName}". The behavior-added field may collide with the mapped field.`
       });
     }
   }
@@ -3928,8 +4024,8 @@ var BasePattern = definePattern({
 });
 
 // src/patterns/library/junction.pattern.ts
-import { z as z7 } from "zod";
-var JunctionPatternConfigSchema = z7.object({}).strict();
+import { z as z8 } from "zod";
+var JunctionPatternConfigSchema = z8.object({}).strict();
 var JunctionPattern = definePattern({
   name: "Junction",
   description: "Explicit many-to-many junction with role + temporal + sourcing metadata",
@@ -3975,30 +4071,30 @@ var MetadataPattern = definePattern({
   description: "History-tracked metadata rows \u2014 entity-id + type scoped lookups"
 });
 
-// src/patterns/library/synced.pattern.ts
-var SyncedPattern = definePattern({
-  name: "Synced",
+// src/patterns/library/integrated.pattern.ts
+var IntegratedPattern = definePattern({
+  name: "Integrated",
   extends: ["Base"],
-  repositoryClass: "SyncedEntityRepository",
-  serviceClass: "SyncedEntityService",
-  repositoryImport: "@shared/base-classes/synced-entity-repository",
-  serviceImport: "@shared/base-classes/synced-entity-service",
+  repositoryClass: "IntegratedEntityRepository",
+  serviceClass: "IntegratedEntityService",
+  repositoryImport: "@shared/base-classes/integrated-entity-repository",
+  serviceImport: "@shared/base-classes/integrated-entity-service",
   repositoryInheritedMethods: [
     "findById, findByIds, list, count, exists, create, update, delete, upsertMany",
     "findByExternalId, findManyByExternalIds, findAllByUserId, findVisibleByUserId",
-    "syncUpsertOne, findByExternalIdProjected, softDeleteByExternalId, syncUpsert"
+    "integrationUpsertOne, findByExternalIdProjected, softDeleteByExternalId, integrationUpsert"
   ],
   serviceInheritedMethods: [
     "findById, findByIds, list, count, exists, create, update, delete",
     "findByExternalId, findAllByUserId, findVisibleByUserId"
   ],
   impliedBehaviors: ["external_id_tracking"],
-  description: "External CRM/system sync columns and syncUpsert methods"
+  description: "External CRM/system integration columns and integrationUpsert methods"
 });
 
 // src/patterns/library/index.ts
 registerLibraryPattern(BasePattern);
-registerLibraryPattern(SyncedPattern);
+registerLibraryPattern(IntegratedPattern);
 registerLibraryPattern(ActivityPattern);
 registerLibraryPattern(KnowledgePattern);
 registerLibraryPattern(MetadataPattern);
@@ -4060,11 +4156,11 @@ export {
   BASE_JUNCTION_FIELD_NAMES,
   BaseJunctionFields,
   BasePattern,
+  IntegratedPattern,
   JunctionDefinitionSchema,
   JunctionPattern,
   KnowledgePattern,
   MetadataPattern,
-  SyncedPattern,
   analyzeDomain,
   buildDomainGraph,
   checkConsistency,