@memberjunction/server 5.48.0 → 5.50.0

package/dist/resolvers/IntegrationDiscoveryResolver.js

@@ -14,6 +14,7 @@ var IntegrationDiscoveryResolver_1;
 import { Resolver, Query, Mutation, Arg, Ctx, ObjectType, Field, InputType, Int, Float } from "type-graphql";
 import { CompositeKey, LocalCacheManager, Metadata, RunView, LogError, LogStatus } from "@memberjunction/core";
 import { GetReadOnlyProvider, GetReadWriteProvider } from "../util.js";
+import { UUIDsEqual } from "@memberjunction/global";
 import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
 import { ConnectorFactory, IntegrationEngine, IntegrationSchemaSync, decideSchemaLimitViolations, IntegrationConnectorCreationPipeline, IntegrationActionGenerator } from "@memberjunction/integration-engine";
 import { IntegrationEngineBase } from "@memberjunction/integration-engine-base";
@@ -22,6 +23,7 @@ import { RuntimeSchemaManager } from "@memberjunction/schema-engine";
 import { IntegrationProgressReader } from "@memberjunction/integration-progress-artifacts";
 import { ResolverBase } from "../generic/ResolverBase.js";
 import { IntegrationCustomColumnPromoter } from "../integration/CustomColumnPromoter.js";
+import { ComputeCascadeRemovalSet, ComputeRemovedDependencyWarnings, DisableUnselectedEntityMaps, ReenableFieldMapsForEntityMap, ResetPullWatermarks, SetEntityMapEnabled } from "../integration/EntityMapLifecycle.js";
 import { RequireSystemUser } from "../directives/RequireSystemUser.js";
 import { UserCache } from "@memberjunction/sqlserver-dataprovider";
 // ─── RSU Pipeline Output Types ──────────────────────────────────────────────
@@ -43,6 +45,14 @@ __decorate([
     Field(),
     __metadata("design:type", String)
 ], RSUStepOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], RSUStepOutput.prototype, "StepIndex", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], RSUStepOutput.prototype, "StepTotal", void 0);
 RSUStepOutput = __decorate([
     ObjectType()
 ], RSUStepOutput);
@@ -137,7 +147,7 @@ __decorate([
     __metadata("design:type", Boolean)
 ], ApplyAllInput.prototype, "StartSync", void 0);
 __decorate([
-    Field(() => Boolean, { nullable: true, defaultValue: false, description: 'If true, ignores watermarks and does a full re-fetch' }),
+    Field(() => Boolean, { nullable: true, description: 'If true, ignores watermarks and does a full re-fetch. When OMITTED: defaults to TRUE on the connector\'s FIRST apply (no prior entity maps — a full sync by default for the first sync), FALSE thereafter.' }),
     __metadata("design:type", Boolean)
 ], ApplyAllInput.prototype, "FullSync", void 0);
 __decorate([
@@ -148,6 +158,10 @@ __decorate([
     Field({ nullable: true, defaultValue: 'Pull', description: 'SyncDirection applied to all created entity maps: Pull | Push | Bidirectional. Defaults to Pull.' }),
     __metadata("design:type", String)
 ], ApplyAllInput.prototype, "DefaultSyncDirection", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: 'disable', description: 'Remove-as-disable: what to do with existing entity maps whose object is NOT in this selection. "disable" (default) = Status=Disabled + SyncEnabled=false (+ field maps disabled; data kept, re-selection re-enables). "ignore" = leave them untouched (additive apply — use for subset/partial applies).' }),
+    __metadata("design:type", String)
+], ApplyAllInput.prototype, "UnselectedAction", void 0);
 ApplyAllInput = __decorate([
     InputType()
 ], ApplyAllInput);
@@ -315,6 +329,10 @@ __decorate([
     Field({ nullable: true, description: 'Override sync direction stored in the created schedule: Pull | Push | Bidirectional.' }),
     __metadata("design:type", String)
 ], ApplyAllBatchInput.prototype, "ScheduleSyncDirection", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: 'disable', description: 'Remove-as-disable (same as ApplyAllInput.UnselectedAction): "disable" (default) disables entity maps whose object is absent from each connector\'s selection; "ignore" leaves them untouched.' }),
+    __metadata("design:type", String)
+], ApplyAllBatchInput.prototype, "UnselectedAction", void 0);
 ApplyAllBatchInput = __decorate([
     InputType()
 ], ApplyAllBatchInput);
@@ -461,6 +479,26 @@ __decorate([
     Field(() => [String], { nullable: true }),
     __metadata("design:type", Array)
 ], SchemaEvolutionOutput.prototype, "Warnings", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], SchemaEvolutionOutput.prototype, "NewObjects", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], SchemaEvolutionOutput.prototype, "RemovedObjects", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], SchemaEvolutionOutput.prototype, "CascadeRemovedObjects", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], SchemaEvolutionOutput.prototype, "ChangedObjects", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], SchemaEvolutionOutput.prototype, "WatermarksReset", void 0);
 SchemaEvolutionOutput = __decorate([
     ObjectType()
 ], SchemaEvolutionOutput);
@@ -1812,6 +1850,14 @@ __decorate([
     Field({ nullable: true }),
     __metadata("design:type", Boolean)
 ], OperationProgressOutput.prototype, "RSURunning", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "RSUStepIndex", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], OperationProgressOutput.prototype, "RSUStepTotal", void 0);
 __decorate([
     Field({ nullable: true }),
     __metadata("design:type", Number)
@@ -2148,6 +2194,10 @@ __decorate([
     Field(),
     __metadata("design:type", Boolean)
 ], ListSourceObjectsItem.prototype, "IsCustom", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], ListSourceObjectsItem.prototype, "DependsOn", void 0);
 ListSourceObjectsItem = __decorate([
     ObjectType()
 ], ListSourceObjectsItem);
@@ -2274,8 +2324,12 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     SupportsIncrementalSync: true,
                     SupportsWrite: true,
                 }));
+            // DAG exposure: per-object parent names from the same FK graph the sync
+            // engine layers by, so a consumer can auto-check dependencies at selection time.
+            const depsByName = this.computeObjectDependencyNames(companyIntegration.IntegrationID);
             const merged = sourceObjects.map(o => {
                 const existing = existingByName.get(o.Name);
+                const dependsOn = depsByName.get(o.Name.toLowerCase());
                 return {
                     Name: o.Name,
                     Label: o.Label,
@@ -2285,6 +2339,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     AlreadyPersisted: existing != null,
                     IntegrationObjectID: existing?.ID,
                     IsCustom: this.isCustomObjectName(o.Name, existing?.IsCustom),
+                    DependsOn: dependsOn && dependsOn.length > 0 ? dependsOn : undefined,
                 };
             });
             merged.sort((a, b) => a.Name.localeCompare(b.Name));
@@ -2326,6 +2381,53 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             return existingIsCustom;
         return name.endsWith('__c');
     }
+    /**
+     * DAG exposure: object name (lowercased) → sorted parent object names, derived from
+     * the SAME dependency edges the sync engine layers by — hard FK pointers
+     * (IntegrationObjectField.RelatedIntegrationObjectID) plus soft-FK declarations in the IO's
+     * Configuration (parentObjectName / parentObjectNames map / ReferencedType). Reads the
+     * engine cache only (no DB round-trip); objects with no persisted IO row have no entry.
+     */
+    computeObjectDependencyNames(integrationID) {
+        const engine = IntegrationEngineBase.Instance;
+        const ios = engine.GetIntegrationObjectsByIntegrationID(integrationID);
+        const nameById = new Map(ios.map(io => [io.ID.toUpperCase(), io.Name]));
+        const byLowerName = new Map(ios.map(io => [io.Name.toLowerCase(), io]));
+        const deps = new Map();
+        for (const io of ios) {
+            const parents = new Set();
+            for (const f of engine.GetIntegrationObjectFields(io.ID)) {
+                const parentID = f.RelatedIntegrationObjectID?.toUpperCase();
+                if (!parentID || UUIDsEqual(parentID, io.ID))
+                    continue;
+                const parentName = nameById.get(parentID);
+                if (parentName)
+                    parents.add(parentName);
+            }
+            const cfgRaw = io.Configuration;
+            if (cfgRaw) {
+                try {
+                    const cfg = JSON.parse(cfgRaw);
+                    const candidates = [];
+                    if (cfg.parentObjectName)
+                        candidates.push(cfg.parentObjectName);
+                    if (cfg.ReferencedType)
+                        candidates.push(cfg.ReferencedType);
+                    if (cfg.parentObjectNames && typeof cfg.parentObjectNames === 'object' && !Array.isArray(cfg.parentObjectNames)) {
+                        candidates.push(...Object.values(cfg.parentObjectNames).filter((v) => typeof v === 'string'));
+                    }
+                    for (const c of candidates) {
+                        const match = byLowerName.get(c.toLowerCase());
+                        if (match && !UUIDsEqual(match.ID, io.ID))
+                            parents.add(match.Name);
+                    }
+                }
+                catch { /* non-JSON Configuration → no soft-FK parents */ }
+            }
+            deps.set(io.Name.toLowerCase(), [...parents].sort());
+        }
+        return deps;
+    }
     /**
      * Discovers fields on a specific external object.
      */
@@ -2396,6 +2498,13 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
      * `<cwd>/logs/integration-runs/<runID>/progress.jsonl` artifact.
      */
     async IntegrationRefreshConnectorSchema(companyIntegrationID, universalPKConvention, deactivateAbsent, ctx) {
+        // sync lock: a metadata refresh rewrites the IO/IOF rows a sync reads.
+        if (!IntegrationEngine.AcquireMaintenanceLock(companyIntegrationID, 'metadata refresh')) {
+            return {
+                Success: false, RunID: 'not-started',
+                Message: 'Refresh not started: a sync or another maintenance operation is currently running for this connection. Retry after it completes.',
+            };
+        }
         try {
             const user = this.getAuthenticatedUser(ctx);
             const provider = GetReadWriteProvider(ctx.providers);
@@ -2456,6 +2565,9 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 RunID: 'error',
             };
         }
+        finally {
+            IntegrationEngine.ReleaseMaintenanceLock(companyIntegrationID);
+        }
     }
     /**
      * Generates + persists strongly-typed Action metadata on demand for an
@@ -4035,7 +4147,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 Message: `Batch complete: ${batchResult.SuccessCount} succeeded, ${batchResult.FailureCount} failed`,
                 Items: itemResults,
                 Steps: batchResult.Results[0]?.Steps.map((s) => ({
-                    Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+                    Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message, StepIndex: s.StepIndex, StepTotal: s.StepTotal,
                 })),
                 GitCommitSuccess: batchResult.Results[0]?.GitCommitSuccess,
                 APIRestarted: batchResult.Results[0]?.APIRestarted,
@@ -4164,6 +4276,19 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             for (let i = 0; i < resolvedNames.length; i++) {
                 sourceObjectFields[resolvedNames[i]] = resolved.sourceObjects[i].Fields ?? null;
             }
+            // the sync after a connector's FIRST apply defaults to FULL ("always full
+            // generally as the default"); later applies default incremental. "First" = no entity
+            // map existed for this connection before this apply. Explicit input always wins.
+            const priorMapsResult = await new RunView().RunView({
+                EntityName: 'MJ: Company Integration Entity Maps',
+                ExtraFilter: `CompanyIntegrationID='${input.CompanyIntegrationID.replace(/'/g, "''")}'`,
+                Fields: ['ID'],
+                MaxRows: 1,
+                ResultType: 'simple',
+                BypassCache: true,
+            }, user);
+            const hadPriorMaps = priorMapsResult.Success && priorMapsResult.Results.length > 0;
+            const effectiveFullSync = input.FullSync ?? !hadPriorMaps;
             const pendingPayload = {
                 CompanyIntegrationID: input.CompanyIntegrationID,
                 SourceObjectNames: resolvedNames,
@@ -4172,19 +4297,22 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 CronExpression: input.CronExpression,
                 ScheduleTimezone: input.ScheduleTimezone,
                 StartSync: input.StartSync,
-                FullSync: input.FullSync ?? false,
+                FullSync: effectiveFullSync,
                 SyncScope: input.SyncScope ?? 'created',
+                UnselectedAction: (input.UnselectedAction ?? 'disable'),
                 CreatedAt: new Date().toISOString(),
             };
             rsuInput.PostRestartFiles = [
                 { Path: pendingFilePath, Content: JSON.stringify(pendingPayload, null, 2) }
             ];
-            // Step 5: Run pipeline (restart kills process at the end)
+            // Step 5: Run pipeline (restart kills process at the end).
+            // Retrying variant — an install should not die because the migration hit a dropped
+            // connection or a transient lock; it only replays while nothing has been applied.
             const rsm = RuntimeSchemaManager.Instance;
-            const batchResult = await rsm.RunPipelineBatch([rsuInput]);
+            const batchResult = await rsm.RunPipelineBatchWithRetry([rsuInput]);
             const migrationSucceeded = batchResult.SuccessCount > 0;
             const pipelineSteps = batchResult.Results[0]?.Steps.map((s) => ({
-                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message, StepIndex: s.StepIndex, StepTotal: s.StepTotal,
             }));
             // If pipeline failed, clean up pending file and return error
             if (!migrationSucceeded) {
@@ -4205,6 +4333,15 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             if (skipRestart) {
                 await provider.Refresh();
                 const entityMapsCreated = await this.createEntityAndFieldMaps(input.CompanyIntegrationID, objects, connector, companyIntegration, schemaName, user, provider, input.DefaultSyncDirection ?? 'Pull');
+                // Remove-as-disable: objects absent from THIS selection get their entity
+                // map + field maps disabled (data kept; re-selection re-enables). 'ignore' opts out
+                // for additive/subset applies (e.g. test-harness per-scope runs).
+                if ((input.UnselectedAction ?? 'disable') !== 'ignore') {
+                    const disabledObjects = await DisableUnselectedEntityMaps(input.CompanyIntegrationID, resolvedNames, user, provider);
+                    if (disabledObjects.length > 0) {
+                        console.log(`[IntegrationApplyAll] Disabled ${disabledObjects.length} unselected entity map(s): ${disabledObjects.join(', ')}`);
+                    }
+                }
                 const createdMapIDs = entityMapsCreated.map(em => em.EntityMapID).filter(Boolean);
                 const scopedMapIDs = input.SyncScope === 'all' ? undefined : createdMapIDs;
                 // Skip sync when SyncScope='created' but 0 new maps were
@@ -4214,7 +4351,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 const shouldStartSync = input.StartSync !== false &&
                     (input.SyncScope === 'all' || createdMapIDs.length > 0);
                 const syncRunID = shouldStartSync
-                    ? await this.startSyncAfterApply(input.CompanyIntegrationID, user, scopedMapIDs, input.FullSync)
+                    ? await this.startSyncAfterApply(input.CompanyIntegrationID, user, scopedMapIDs, effectiveFullSync)
                     : null;
                 // Create schedule if requested
                 let scheduledJobID;
@@ -4340,6 +4477,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 existing = existingMapResult.Results[0];
         }
         let em;
+        const wasDisabled = existing ? existing.Status !== 'Active' || existing.SyncEnabled === false : false;
         if (existing) {
             em = existing; // reuse — keeps the map stable across re-applies
         }
@@ -4358,6 +4496,12 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             LogError(`IntegrationApplyAll: failed to save entity map for ${obj.SourceObjectName}`);
             return null;
         }
+        // Re-add re-enables: a previously-removed (disabled) object that is re-selected
+        // comes back WITH its field maps — the create-field-maps idempotency below skips existing
+        // rows, so without this they would stay Disabled forever.
+        if (wasDisabled) {
+            await ReenableFieldMapsForEntityMap(em.ID, user, md);
+        }
         // Discover fields from the source and create 1:1 field maps
         const fieldMapCount = await this.createFieldMapsForEntityMap(em.ID, obj.SourceObjectName, connector, companyIntegration, user, md);
         return {
@@ -4393,7 +4537,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 fm.EntityMapID = entityMapID;
                 fm.SourceFieldName = field.Name;
                 fm.DestinationFieldName = field.Name.replace(/[^A-Za-z0-9_]/g, '_');
-                fm.IsKeyField = field.IsUniqueKey;
+                fm.IsKeyField = field.IsPrimaryKey ?? false; // key on the record's PRIMARY key (identity), consistent with processRSUPendingWork + U1 (PK ≠ unique)
                 fm.IsRequired = field.IsRequired;
                 fm.Direction = 'SourceToDest';
                 fm.Status = 'Active';
@@ -4600,6 +4744,13 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             if (await ciCheck.InnerLoad(CompositeKey.FromID(companyIntegrationID)) && ciCheck.IsActive === false) {
                 return { Success: false, Message: 'Connector is deactivated (IsActive=false); sync not started' };
             }
+            // sync lock: refuse while a metadata refresh / schema evolution / RSU pipeline
+            // holds the maintenance lock for this connection (the engine also refuses — this gives
+            // the client an immediate, unambiguous answer).
+            const maintenance = IntegrationEngine.GetMaintenanceLock(companyIntegrationID);
+            if (maintenance) {
+                return { Success: false, Message: `Sync not started: ${maintenance.Reason} is in progress for this connection (since ${maintenance.AcquiredAt.toISOString()}). Retry after it completes.` };
+            }
             const syncOptions = {};
             if (fullSync)
                 syncOptions.FullSync = true;
@@ -4648,10 +4799,21 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             // null RunID: an optimistic, untrackable result that read as "started" when nothing
             // could be followed. Poll briefly for ANY run for this connector stamped at/after the
             // fire instant; that catches both the still-running and the already-finished cases.
+            //
+            // The row itself isn't created until executeSyncInternal reaches CreateRunRecord,
+            // which runs AFTER LoadRunConfiguration (loads every entity map + field map + builds
+            // the connector instance) — for a large connector (HubSpot, 168 entity maps) that
+            // synchronous setup alone can take several seconds, so a short fixed poll window can
+            // elapse before the row exists at all, not because the sync failed. Live-verified: a
+            // HubSpot StartSync call reported "no run created" while the run (confirmed present in
+            // the DB moments later) was genuinely syncing. Keep the fast path fast (first 2s still
+            // polled every 200ms) but extend the tail so large connectors get a fair window before
+            // we honestly report failure.
             const firedAtFilter = firedAt.toISOString();
             let run = null;
-            for (let attempt = 0; attempt < 15 && !run; attempt++) {
-                await new Promise(resolve => setTimeout(resolve, 200));
+            const pollIntervalsMs = [...Array(10).fill(200), ...Array(20).fill(1000)];
+            for (let attempt = 0; attempt < pollIntervalsMs.length && !run; attempt++) {
+                await new Promise(resolve => setTimeout(resolve, pollIntervalsMs[attempt]));
                 const rv = new RunView();
                 const runResult = await rv.RunView({
                     EntityName: 'MJ: Company Integration Runs',
@@ -4797,8 +4959,20 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 return { Success: false, Message: `Scheduled job type not found for driver '${driverClass}' (kind='${jobKind}')` };
             }
             const jobTypeID = jobTypeResult.Results[0].ID;
+            // U7 — SERVER-SIDE uniqueness per (CompanyIntegration, job kind/driver): a client
+            // name-regex is not a guarantee, and duplicate jobs mean duplicate sync/rediscovery
+            // runs. When an active/paused job of this kind already targets this connection,
+            // UPDATE it in place instead of creating a twin.
             const job = await md.GetEntityObject('MJ: Scheduled Jobs', user);
-            job.NewRecord();
+            const existingJob = await this.findExistingScheduledJob(jobTypeID, input.CompanyIntegrationID, user);
+            let updatedInPlace = false;
+            if (existingJob) {
+                const loaded = await job.InnerLoad(CompositeKey.FromID(existingJob.ID));
+                if (loaded)
+                    updatedInPlace = true;
+            }
+            if (!updatedInPlace)
+                job.NewRecord();
             job.JobTypeID = jobTypeID;
             job.Name = input.Name;
             if (input.Description)
@@ -4833,13 +5007,44 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 ci.CronExpression = input.CronExpression;
                 await ci.Save();
             }
-            return { Success: true, Message: 'Schedule created', ScheduledJobID: job.ID };
+            return {
+                Success: true,
+                Message: updatedInPlace
+                    ? 'Schedule updated — an active schedule of this kind already existed for this connection (server-side uniqueness)'
+                    : 'Schedule created',
+                ScheduledJobID: job.ID,
+            };
         }
         catch (e) {
             LogError(`IntegrationCreateSchedule error: ${e}`);
             return { Success: false, Message: this.formatError(e) };
         }
     }
+    /**
+     * U7 — server-side schedule uniqueness: finds an existing (non-deleted) scheduled job of the
+     * given job type that targets the given CompanyIntegration (its Configuration JSON carries
+     * CompanyIntegrationID). Matched case-insensitively across UUID casings (SQL Server upper /
+     * PostgreSQL lower). Returns the newest match or null.
+     */
+    async findExistingScheduledJob(jobTypeID, companyIntegrationID, user) {
+        const esc = (s) => s.replace(/'/g, "''");
+        const lower = esc(companyIntegrationID.toLowerCase());
+        const upper = esc(companyIntegrationID.toUpperCase());
+        const result = await new RunView().RunView({
+            EntityName: 'MJ: Scheduled Jobs',
+            ExtraFilter: `JobTypeID='${esc(jobTypeID)}' AND Status IN ('Active','Paused') AND ` +
+                // Structured "CompanyIntegrationID":"<uuid>" predicate (same form as IntegrationListSchedules),
+                // NOT a bare-UUID substring — so this CI's id can't false-match the same UUID appearing in
+                // another config key (e.g. RelatedCompanyIntegrationID) and repurpose an unrelated job.
+                `(Configuration LIKE '%"CompanyIntegrationID":"${lower}"%' OR Configuration LIKE '%"CompanyIntegrationID":"${upper}"%')`,
+            OrderBy: '__mj_CreatedAt DESC',
+            Fields: ['ID'],
+            MaxRows: 1,
+            ResultType: 'simple',
+            BypassCache: true, // uniqueness must see committed jobs, not a stale filtered cache
+        }, user);
+        return result.Success && result.Results.length > 0 ? result.Results[0] : null;
+    }
     async IntegrationUpdateSchedule(scheduledJobID, cronExpression, timezone, name, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
@@ -5172,7 +5377,10 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     OperationType: 'rsu',
                     IsRunning: true,
                     RSURunning: true,
-                    RSUStep: rsuStatus.LastRunResult ?? 'running',
+                    // U11 — determinate "step N of M: <name>" instead of an indeterminate spinner
+                    RSUStep: rsuStatus.CurrentStepName ?? rsuStatus.LastRunResult ?? 'running',
+                    RSUStepIndex: rsuStatus.CurrentStepIndex ?? undefined,
+                    RSUStepTotal: rsuStatus.StepTotal ?? undefined,
                     StartedAt: rsuStatus.LastRunAt?.toISOString(),
                     ElapsedMs: rsuStatus.LastRunAt ? Date.now() - rsuStatus.LastRunAt.getTime() : undefined,
                 };
@@ -5652,6 +5860,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     SyncScope: input.SyncScope ?? 'created',
                     SyncDirection: input.SyncDirection,
                     ScheduleSyncDirection: input.ScheduleSyncDirection,
+                    UnselectedAction: (input.UnselectedAction ?? 'disable'),
                     CreatedAt: new Date().toISOString(),
                 };
                 rsuInput.PostRestartFiles = [
@@ -5696,10 +5905,13 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     FailureCount: connectorResults.length,
                 };
             }
-            // Phase 2: Run all successful RSU inputs through one pipeline batch
+            // Phase 2: Run all successful RSU inputs through one pipeline batch.
+            // Retrying variant — a multi-connector install is the longest-running thing a user
+            // does here, and it should not be lost to one transient step. Replays only while
+            // nothing has been applied, so a partially-committed batch is never re-executed.
             const pipelineInputs = successfulBuilds.map(b => b.rsuInput);
             const rsm = RuntimeSchemaManager.Instance;
-            const batchResult = await rsm.RunPipelineBatch(pipelineInputs);
+            const batchResult = await rsm.RunPipelineBatchWithRetry(pipelineInputs);
             // Phase 3: Post-pipeline — create entity maps, field maps, schedules for each success
             for (let i = 0; i < successfulBuilds.length; i++) {
                 const build = successfulBuilds[i];
@@ -5763,7 +5975,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 connectorResults.push(connResult);
             }
             const pipelineSteps = batchResult.Results[0]?.Steps.map((s) => ({
-                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
+                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message, StepIndex: s.StepIndex, StepTotal: s.StepTotal,
             }));
             const successCount = connectorResults.filter(r => r.Success).length;
             const failureCount = connectorResults.filter(r => !r.Success).length;
@@ -5804,8 +6016,13 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 return null;
             }
             const jobTypeID = jobTypeResult.Results[0].ID;
+            // U7 — same server-side uniqueness as IntegrationCreateSchedule: update the existing
+            // sync job for this connection in place rather than creating a duplicate.
             const job = await md.GetEntityObject('MJ: Scheduled Jobs', user);
-            job.NewRecord();
+            const existingJob = await this.findExistingScheduledJob(jobTypeID, companyIntegrationID, user);
+            const loadedExisting = existingJob ? await job.InnerLoad(CompositeKey.FromID(existingJob.ID)) : false;
+            if (!loadedExisting)
+                job.NewRecord();
             job.JobTypeID = jobTypeID;
             job.Name = `${integrationName} Sync`;
             job.CronExpression = cronExpression;
@@ -6024,7 +6241,15 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
      * applies ALTER TABLE migrations via the RSU pipeline.
      * Compares the current connector introspection against existing MJ entities.
      */
-    async IntegrationSchemaEvolution(companyIntegrationID, platform, skipGitCommit, skipRestart, ctx) {
+    async IntegrationSchemaEvolution(companyIntegrationID, platform, skipGitCommit, skipRestart, autoEnableNewObjects, deactivateAbsent, cascadeRemoveDependents, ctx) {
+        // sync lock: schema evolution rewrites the metadata, field maps and DDL a sync
+        // reads — data syncs (manual + scheduled) must not run while this is in flight.
+        if (!IntegrationEngine.AcquireMaintenanceLock(companyIntegrationID, 'schema evolution')) {
+            return {
+                Success: false, HasChanges: false,
+                Message: 'Schema evolution not started: a sync or another maintenance operation is currently running for this connection. Retry after it completes.',
+            };
+        }
         try {
             const user = this.getAuthenticatedUser(ctx);
             const validatedPlatform = this.validatePlatform(platform);
@@ -6032,22 +6257,89 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user, md);
             const schemaName = this.deriveSchemaName(companyIntegration.Integration);
             const rv = new RunView();
-            // Step 1: Get existing entity maps for this CompanyIntegration
-            const entityMapsResult = await rv.RunView({
+            // ── Phase 1 — FULL RE-RESOLUTION (: "the exact same algorithm as before") ──
+            // Re-run the creation pipeline: introspect (static + runtime discovery), persist with
+            // the external-wins-when-present overlay, deactivate absent (gated on authoritative
+            // discovery), PK-classify the residual. The diff below is computed against the
+            // RESULT of this resolution, exactly as the first-time flow computed its state.
+            const pipeline = new IntegrationConnectorCreationPipeline();
+            const refresh = await pipeline.Run({
+                Connector: connector,
+                CompanyIntegration: companyIntegration,
+                ContextUser: user,
+                Provider: md,
+                TriggerType: 'Manual',
+                ConsoleMirror: true,
+                DeactivateAbsent: deactivateAbsent ?? this.readConfigBool(companyIntegration.Configuration, 'deactivateAbsent') ?? true,
+            });
+            if (!refresh.Success) {
+                return { Success: false, HasChanges: false, Message: `Schema evolution aborted — metadata re-resolution failed: ${refresh.FailureMessage ?? 'unknown error'}` };
+            }
+            await md.Refresh();
+            await IntegrationEngine.Instance.Config(true, user, md);
+            // ── Phase 2 — DIFF: resolved-Active objects vs prior entity maps ──
+            const activeIOs = IntegrationEngineBase.Instance.GetActiveIntegrationObjects(companyIntegration.IntegrationID);
+            const activeNamesLower = new Set(activeIOs.map(o => o.Name.toLowerCase()));
+            const priorMapsResult = await rv.RunView({
                 EntityName: 'MJ: Company Integration Entity Maps',
                 ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
-                ResultType: 'simple',
-                Fields: ['ID', 'ExternalObjectName', 'EntityID']
+                ResultType: 'entity_object',
+                BypassCache: true, // the diff must read committed state
             }, user);
-            if (!entityMapsResult.Success || entityMapsResult.Results.length === 0) {
+            const priorMaps = priorMapsResult.Success ? priorMapsResult.Results : [];
+            const priorByLowerName = new Map(priorMaps.map(m => [(m.ExternalObjectName ?? '').toLowerCase(), m]));
+            const newObjects = activeIOs.filter(io => !priorByLowerName.has(io.Name.toLowerCase())).map(io => io.Name);
+            const removedObjects = priorMaps
+                .filter(m => m.ExternalObjectName && !activeNamesLower.has(m.ExternalObjectName.toLowerCase()))
+                .map(m => m.ExternalObjectName);
+            const continuingMaps = priorMaps.filter(m => m.ExternalObjectName && activeNamesLower.has(m.ExternalObjectName.toLowerCase()));
+            // ── Phase 3 — REMOVED objects: disable EM + EFMs (data + tables KEPT) ──
+            // Uses the same remove-as-disable helper as ApplyAll: everything not in the resolved
+            // set is disabled; a later re-appearance re-enables (reactivate-on-rediscover).
+            // DAG handling (rsuplan "adding and removing tables"): dependents of a removed object
+            // are NOT auto-removed by default — each broken parent edge is surfaced as a warning so
+            // a consumer can prompt the user. With cascadeRemoveDependents=true (the "force remove
+            // those too" affordance), the TRANSITIVE closure of still-active dependents is disabled
+            // alongside the removed objects (still remove-as-disable, reversible). Edges come from
+            // the same dependency map the sync engine layers by.
+            const depMap = removedObjects.length > 0
+                ? this.computeObjectDependencyNames(companyIntegration.IntegrationID)
+                : new Map();
+            const cascadeRemoved = cascadeRemoveDependents && removedObjects.length > 0
+                ? ComputeCascadeRemovalSet(activeIOs.map(io => io.Name), removedObjects, depMap)
+                : [];
+            const cascadeLower = new Set(cascadeRemoved.map(n => n.toLowerCase()));
+            const keepNames = activeIOs.map(io => io.Name).filter(n => !cascadeLower.has(n.toLowerCase()));
+            const dagRemovalWarnings = removedObjects.length > 0 && !cascadeRemoveDependents
+                ? ComputeRemovedDependencyWarnings(keepNames, removedObjects, depMap)
+                : [];
+            for (const w of dagRemovalWarnings)
+                LogStatus(`[SchemaEvolution][DAG] ${w}`);
+            if (cascadeRemoved.length > 0)
+                LogStatus(`[SchemaEvolution][DAG] cascade-removing ${cascadeRemoved.length} dependent object(s): ${cascadeRemoved.join(', ')}`);
+            if (removedObjects.length > 0 || cascadeRemoved.length > 0) {
+                await DisableUnselectedEntityMaps(companyIntegrationID, keepNames, user, md);
+            }
+            // ── Phase 4 — schema build over continuing + new objects (minus cascade-removed) ──
+            const evolveNames = [
+                ...continuingMaps.map(m => m.ExternalObjectName).filter(n => !cascadeLower.has(n.toLowerCase())),
+                ...newObjects,
+            ];
+            if (evolveNames.length === 0) {
+                const removedTotal = removedObjects.length + cascadeRemoved.length;
                 return {
-                    Success: false, Message: 'No entity maps found — nothing to evolve',
-                    HasChanges: false,
+                    Success: true, HasChanges: removedTotal > 0,
+                    Message: removedTotal > 0
+                        ? `No objects to evolve — ${removedTotal} removed object(s) disabled${cascadeRemoved.length > 0 ? ` (${cascadeRemoved.length} via cascade)` : ''}`
+                        : 'No entity maps and no resolved objects — nothing to evolve',
+                    RemovedObjects: removedObjects.length > 0 ? removedObjects : undefined,
+                    CascadeRemovedObjects: cascadeRemoved.length > 0 ? cascadeRemoved : undefined,
+                    Warnings: dagRemovalWarnings.length > 0 ? dagRemovalWarnings : undefined,
                 };
             }
-            const sourceObjectNames = entityMapsResult.Results.map(em => em.ExternalObjectName);
-            const objects = this.buildObjectInputsFromNames(sourceObjectNames, schemaName);
-            // Step 2: Build ExistingTables from Metadata.Entities matching the schema
+            const objects = this.buildObjectInputsFromNames(evolveNames, schemaName);
+            // Build ExistingTables from Metadata.Entities matching the schema (continuing objects
+            // have a table; new objects don't — SchemaBuilder CREATEs those, ALTERs the rest)
             const existingTables = [];
             for (const obj of objects) {
                 const entityInfo = md.Entities.find(e => e.SchemaName.toLowerCase() === schemaName.toLowerCase()
@@ -6067,12 +6359,12 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     });
                 }
             }
-            // Step 3: Introspect current schema from connector
-            const introspect = connector.IntrospectSchema.bind(connector);
-            const sourceSchema = await introspect(companyIntegration, user);
+            // Source of truth for the evolution = the PERSISTED post-resolution rows (the refresh in
+            // Phase 1 just wrote them via the overlay) — no duplicate vendor introspect.
+            const sourceSchema = this.buildSourceSchemaFromPersistedRows(companyIntegration.IntegrationID);
             // Normalize names to match source schema casing
             const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
-            const normalizedNames = sourceObjectNames.map(n => nameMap.get(n.toLowerCase()) ?? n);
+            const normalizedNames = evolveNames.map(n => nameMap.get(n.toLowerCase()) ?? n);
             // Also normalize the objects array SourceObjectName
             for (const obj of objects) {
                 const exact = nameMap.get(obj.SourceObjectName.toLowerCase());
@@ -6083,7 +6375,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             const filteredSchema = {
                 Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
             };
-            // Step 4: Build target configs and SchemaBuilder input with ExistingTables
+            // Build target configs and SchemaBuilder input with ExistingTables
             const targetConfigs = this.buildTargetConfigs(objects, filteredSchema, validatedPlatform, connector);
             const schemaInput = {
                 SourceSchema: filteredSchema,
@@ -6097,7 +6389,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 ExistingTables: existingTables,
                 EntitySettingsForTargets: {}
             };
-            // Step 5: Build schema — SchemaBuilder handles evolution (ALTER TABLE) internally
+            // ── Phase 5 — build schema (SchemaBuilder CREATEs new tables, ALTERs changed ones) ──
             const builder = new SchemaBuilder();
             const schemaOutput = builder.BuildSchema(schemaInput);
             if (schemaOutput.Errors.length > 0) {
@@ -6108,18 +6400,10 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
                 };
             }
-            // Step 6: Check if any migration SQL was generated
-            if (schemaOutput.MigrationFiles.length === 0) {
-                return {
-                    Success: true,
-                    Message: 'No schema changes detected',
-                    HasChanges: false,
-                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
-                };
-            }
-            // Step 7: Count added/modified columns by re-diffing
+            // Per-object DDL diff for CHANGED detection (drives U10 watermark resets + reporting)
             let addedColumns = 0;
             let modifiedColumns = 0;
+            const changedObjects = [];
             const evolution = new SchemaEvolution();
             for (const existing of existingTables) {
                 const config = targetConfigs.find(c => c.SchemaName.toLowerCase() === existing.SchemaName.toLowerCase()
@@ -6132,36 +6416,216 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 const diff = evolution.DiffSchema(sourceObj, config, existing, validatedPlatform);
                 addedColumns += diff.AddedColumns.length;
                 modifiedColumns += diff.ModifiedColumns.length;
+                if (diff.AddedColumns.length > 0 || diff.ModifiedColumns.length > 0) {
+                    changedObjects.push(config.SourceObjectName);
+                }
             }
-            // Step 8: Run RSU pipeline
-            const rsuInput = builder.BuildRSUInput(schemaOutput, schemaInput, {
-                SkipGitCommit: skipGitCommit,
-                SkipRestart: skipRestart,
-            });
-            const rsm = RuntimeSchemaManager.Instance;
-            const batchResult = await rsm.RunPipelineBatch([rsuInput]);
-            const pipelineResult = batchResult.Results[0];
-            const pipelineSteps = pipelineResult?.Steps.map((s) => ({
-                Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message,
-            }));
+            // ── Phase 6 — reconcile CONTINUING maps' field maps to the resolution ──
+            // Added source fields get field maps (Active on enabled maps, Disabled on disabled
+            // maps); field maps whose source field vanished from the resolution are disabled.
+            // Field maps carry no entity FK, so this is restart-safe done here, pre-RSU.
+            const iosByLowerName = new Map(activeIOs.map(io => [io.Name.toLowerCase(), io]));
+            for (const em of continuingMaps) {
+                const io = iosByLowerName.get((em.ExternalObjectName ?? '').toLowerCase());
+                if (!io)
+                    continue;
+                const fmChanges = await this.reconcileFieldMapsForEntityMap(em, io.ID, user, md);
+                if ((fmChanges.Added > 0 || fmChanges.Disabled > 0) && em.ExternalObjectName && !changedObjects.includes(em.ExternalObjectName)) {
+                    changedObjects.push(em.ExternalObjectName);
+                }
+            }
+            // ── Phase 7 — U10: reset the Pull watermark of every CHANGED object so the next sync
+            // full-fetches + backfills the schema change (content-hash bounds the rewrite cost).
+            const changedLower = new Set(changedObjects.map(n => n.toLowerCase()));
+            const changedMapIDs = continuingMaps
+                .filter(m => m.ExternalObjectName && changedLower.has(m.ExternalObjectName.toLowerCase()))
+                .map(m => m.ID);
+            const resetMapIDs = await ResetPullWatermarks(changedMapIDs, user, md);
+            const watermarksReset = continuingMaps
+                .filter(m => resetMapIDs.some(id => UUIDsEqual(id, m.ID)))
+                .map(m => m.ExternalObjectName);
+            const hasDDLChanges = schemaOutput.MigrationFiles.length > 0;
+            const hasChanges = hasDDLChanges || newObjects.length > 0 || removedObjects.length > 0 || changedObjects.length > 0;
+            if (!hasChanges) {
+                return {
+                    Success: true,
+                    Message: 'No schema changes detected',
+                    HasChanges: false,
+                    Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                };
+            }
+            // ── Phase 8 — run RSU when DDL changed (migrate → codegen → commit → compile → restart) ──
+            let pipelineSteps;
+            let gitCommitSuccess;
+            let apiRestarted;
+            if (hasDDLChanges) {
+                const rsuInput = builder.BuildRSUInput(schemaOutput, schemaInput, {
+                    SkipGitCommit: skipGitCommit,
+                    SkipRestart: skipRestart,
+                    // Schema evolution runs a FULL re-resolution of this connector's schema, so its
+                    // soft-constraint payload is the complete current truth — authorize the writer to
+                    // prune additionalSchemaInfo entries for tables that vanished from the resolution
+                    // (rsuplan: "adds new ones, removes old ones that no longer exist"). Subset
+                    // ApplyAll builds deliberately do NOT set this.
+                    AdditionalSchemaInfoAuthoritative: true,
+                });
+                // NEW objects need entities (post-codegen/restart) before their entity maps can be
+                // created — hand them to the post-restart consumer via the SAME pending-work channel
+                // ApplyAll uses. default: created DISABLED (user enables after the refresh);
+                // autoEnableNewObjects opts in. Removal was already handled in Phase 3 → 'ignore'.
+                if (newObjects.length > 0 && !skipRestart) {
+                    const { join } = await import('node:path');
+                    const rsuWorkDir = process.env.RSU_WORK_DIR || process.cwd();
+                    const pendingFilePath = join(rsuWorkDir, '.rsu_pending', `${Date.now()}-evolution.json`);
+                    rsuInput.PostRestartFiles = [
+                        ...(rsuInput.PostRestartFiles ?? []),
+                        {
+                            Path: pendingFilePath,
+                            Content: JSON.stringify({
+                                CompanyIntegrationID: companyIntegrationID,
+                                SourceObjectNames: newObjects,
+                                SourceObjectFields: Object.fromEntries(newObjects.map(n => [n, null])),
+                                SchemaName: schemaName,
+                                StartSync: false,
+                                SyncScope: 'created',
+                                UnselectedAction: 'ignore',
+                                CreateDisabled: !autoEnableNewObjects,
+                                CreatedAt: new Date().toISOString(),
+                            }, null, 2),
+                        },
+                    ];
+                }
+                const rsm = RuntimeSchemaManager.Instance;
+                const batchResult = await rsm.RunPipelineBatch([rsuInput]);
+                const pipelineResult = batchResult.Results[0];
+                pipelineSteps = pipelineResult?.Steps.map((s) => ({
+                    Name: s.Name, Status: s.Status, DurationMs: s.DurationMs, Message: s.Message, StepIndex: s.StepIndex, StepTotal: s.StepTotal,
+                }));
+                gitCommitSuccess = pipelineResult?.GitCommitSuccess;
+                apiRestarted = pipelineResult?.APIRestarted;
+                if (!pipelineResult?.Success) {
+                    return {
+                        Success: false,
+                        Message: `Pipeline failed: ${pipelineResult?.ErrorMessage ?? 'unknown error'}`,
+                        HasChanges: true,
+                        AddedColumns: addedColumns,
+                        ModifiedColumns: modifiedColumns,
+                        Steps: pipelineSteps,
+                        NewObjects: newObjects.length > 0 ? newObjects : undefined,
+                        RemovedObjects: removedObjects.length > 0 ? removedObjects : undefined,
+                        ChangedObjects: changedObjects.length > 0 ? changedObjects : undefined,
+                        Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                    };
+                }
+                // skipRestart=true: entities exist after provider.Refresh() — create the new
+                // objects' entity maps inline, then apply the disabled-by-default rule.
+                if (newObjects.length > 0 && skipRestart) {
+                    await md.Refresh();
+                    const newObjectInputs = objects.filter(o => newObjects.some(n => n.toLowerCase() === o.SourceObjectName.toLowerCase()));
+                    const created = await this.createEntityAndFieldMaps(companyIntegrationID, newObjectInputs, connector, companyIntegration, schemaName, user, md, 'Pull');
+                    if (!autoEnableNewObjects) {
+                        for (const c of created) {
+                            if (c.EntityMapID)
+                                await SetEntityMapEnabled(c.EntityMapID, false, user, md);
+                        }
+                    }
+                }
+            }
+            const summary = [
+                newObjects.length > 0 ? `${newObjects.length} new object(s) (${autoEnableNewObjects ? 'enabled' : 'created disabled'})` : null,
+                removedObjects.length > 0 ? `${removedObjects.length} removed object(s) disabled` : null,
+                changedObjects.length > 0 ? `${changedObjects.length} changed object(s), ${addedColumns} column(s) added, ${modifiedColumns} modified` : null,
+                watermarksReset.length > 0 ? `${watermarksReset.length} watermark(s) reset for backfill` : null,
+            ].filter(Boolean).join('; ');
             return {
-                Success: pipelineResult?.Success ?? false,
-                Message: pipelineResult?.Success
-                    ? `Schema evolution applied — ${addedColumns} column(s) added, ${modifiedColumns} column(s) modified`
-                    : `Pipeline failed: ${pipelineResult?.ErrorMessage ?? 'unknown error'}`,
+                Success: true,
+                Message: `Schema evolution applied — ${summary || 'no per-object deltas'}`,
                 HasChanges: true,
                 AddedColumns: addedColumns,
                 ModifiedColumns: modifiedColumns,
                 Steps: pipelineSteps,
-                GitCommitSuccess: pipelineResult?.GitCommitSuccess,
-                APIRestarted: pipelineResult?.APIRestarted,
-                Warnings: schemaOutput.Warnings.length > 0 ? schemaOutput.Warnings : undefined,
+                GitCommitSuccess: gitCommitSuccess,
+                APIRestarted: apiRestarted,
+                NewObjects: newObjects.length > 0 ? newObjects : undefined,
+                RemovedObjects: removedObjects.length > 0 ? removedObjects : undefined,
+                CascadeRemovedObjects: cascadeRemoved.length > 0 ? cascadeRemoved : undefined,
+                ChangedObjects: changedObjects.length > 0 ? changedObjects : undefined,
+                WatermarksReset: watermarksReset.length > 0 ? watermarksReset : undefined,
+                Warnings: (dagRemovalWarnings.length + schemaOutput.Warnings.length) > 0
+                    ? [...dagRemovalWarnings, ...schemaOutput.Warnings]
+                    : undefined,
             };
         }
         catch (e) {
             LogError(`IntegrationSchemaEvolution error: ${e}`);
             return { Success: false, Message: this.formatError(e), HasChanges: false };
         }
+        finally {
+            IntegrationEngine.ReleaseMaintenanceLock(companyIntegrationID);
+        }
+    }
+    /**
+     * Refresh diff (continuing objects): reconciles one entity map's field maps to the
+     * post-resolution IOF set — source fields WITHOUT a field map get one created (Active when
+     * the map is enabled, Disabled when it isn't), and field maps whose source field is no
+     * longer Active in the resolution are DISABLED (never deleted — a later re-appearance
+     * re-enables via the same reconciliation, since a disabled FM whose field returns flips
+     * back with SetFieldMapsStatus on re-enable or is simply left disabled until then).
+     */
+    async reconcileFieldMapsForEntityMap(em, integrationObjectID, user, md) {
+        const result = { Added: 0, Disabled: 0 };
+        const activeFields = IntegrationEngineBase.Instance
+            .GetIntegrationObjectFields(integrationObjectID)
+            .filter(f => f.Status === 'Active');
+        const activeFieldNames = new Set(activeFields.map(f => f.Name.toLowerCase()));
+        const mapEnabled = em.Status === 'Active' && em.SyncEnabled === true;
+        const fms = await new RunView().RunView({
+            EntityName: 'MJ: Company Integration Field Maps',
+            ExtraFilter: `EntityMapID='${em.ID}'`,
+            ResultType: 'entity_object',
+            BypassCache: true,
+        }, user);
+        const existingByLower = new Map((fms.Success ? fms.Results : []).map(fm => [(fm.SourceFieldName ?? '').toLowerCase(), fm]));
+        // Added source fields → new field maps (state follows the map's enabled state)
+        for (const field of activeFields) {
+            const existing = existingByLower.get(field.Name.toLowerCase());
+            if (existing) {
+                // Field is back in the resolution — re-enable a previously-disabled map row.
+                if (existing.Status !== 'Active' && mapEnabled) {
+                    existing.Status = 'Active';
+                    if (await existing.Save())
+                        result.Added++; // counted as a change for reporting
+                }
+                continue;
+            }
+            const fm = await md.GetEntityObject('MJ: Company Integration Field Maps', user);
+            fm.NewRecord();
+            fm.EntityMapID = em.ID;
+            fm.SourceFieldName = field.Name;
+            fm.DestinationFieldName = field.Name.replace(/[^A-Za-z0-9_]/g, '_');
+            fm.IsKeyField = field.IsPrimaryKey ?? false; // key on the PRIMARY key (identity), consistent with the initial-apply path + U1 (PK ≠ unique)
+            fm.IsRequired = field.IsRequired === true;
+            fm.Direction = 'SourceToDest';
+            fm.Status = mapEnabled ? 'Active' : 'Inactive';
+            fm.Priority = 0;
+            if (await fm.Save())
+                result.Added++;
+            else
+                LogError(`[IntegrationSchemaEvolution] Failed to create field map '${field.Name}' on ${em.ExternalObjectName}: ${fm.LatestResult?.CompleteMessage ?? 'unknown error'}`);
+        }
+        // Vanished source fields → disable their field maps (data/columns kept)
+        for (const [lowerName, fm] of existingByLower) {
+            if (activeFieldNames.has(lowerName))
+                continue;
+            if (fm.Status === 'Inactive')
+                continue;
+            fm.Status = 'Inactive';
+            if (await fm.Save())
+                result.Disabled++;
+            else
+                LogError(`[IntegrationSchemaEvolution] Failed to disable field map '${fm.SourceFieldName}' on ${em.ExternalObjectName}: ${fm.LatestResult?.CompleteMessage ?? 'unknown error'}`);
+        }
+        return result;
     }
     // ── WEBHOOK HELPER ──────────────────────────────────────────────────
     async sendWebhook(url, payload) {
@@ -6611,9 +7075,12 @@ __decorate([
     __param(1, Arg("platform", { defaultValue: "sqlserver" })),
     __param(2, Arg("skipGitCommit", { defaultValue: false })),
     __param(3, Arg("skipRestart", { defaultValue: false })),
-    __param(4, Ctx()),
+    __param(4, Arg("autoEnableNewObjects", { defaultValue: false, description: 'newly-appeared objects get their entity maps created DISABLED by default (the user enables them after the refresh). Pass true to auto-enable them instead.' })),
+    __param(5, Arg("deactivateAbsent", { nullable: true, description: 'Deactivate IO/IOF absent from this re-discovery (default true — comprehensive refresh; gated on the connector\'s authoritative-discovery getter).' })),
+    __param(6, Arg("cascadeRemoveDependents", { defaultValue: false, description: 'When a removed object has still-active dependents (DAG parent edges), also disable the transitive dependent closure ("force remove those too"). Default false: dependents stay active and each broken edge is surfaced as a warning.' })),
+    __param(7, Ctx()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, Boolean, Boolean, Object]),
+    __metadata("design:paramtypes", [String, String, Boolean, Boolean, Boolean, Boolean, Boolean, Object]),
     __metadata("design:returntype", Promise)
 ], IntegrationDiscoveryResolver.prototype, "IntegrationSchemaEvolution", null);
 IntegrationDiscoveryResolver = IntegrationDiscoveryResolver_1 = __decorate([