Clamp a repositioned event dropped before its predecessor's end

Aligns the drop gesture with the hard-constraint behavior of established
Gantt tools: a successor dropped in violation snaps forward to the first
valid position instead of keeping a violated arrow.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RDEgka4iDRFrenWeWFhunq

Author: rita-codes

docs/data/scheduler/experiments/experiments.md

@@ -22,7 +22,7 @@ Finish-to-Start dependencies on the timeline. The dataset covers every route sha
 
 ## Timeline auto-scheduling (#22857, #22858)
 
-The Finish-to-Start auto-scheduling engine. Moving or resizing an event pushes its violated successors forward on the drop, transitively, as one atomic change — and only when the relationship is actually broken: dragging `Plan` slightly to the right lands inside `Build`'s slack and moves nothing, dragging it past `Build`'s start pushes the whole chain. Moving a predecessor earlier never pulls its successors back. The `Design` diamond reconverges on `Integrate`, which settles once behind the later of its two branches. `Audit` is read-only: pushing `Setup` into it leaves it in place with the violated arrow visible, and nothing beyond it moves. The all-day pair shifts by whole days and stays all-day. Dragging a terminal to close a cycle (for example `Deploy` onto `Plan`) is rejected with a transient toast. The feature has no public API yet, so the demo feeds the internal store parameters.
+The Finish-to-Start auto-scheduling engine. Moving or resizing an event pushes its violated successors forward on the drop, transitively, as one atomic change — and only when the relationship is actually broken: dragging `Plan` slightly to the right lands inside `Build`'s slack and moves nothing, dragging it past `Build`'s start pushes the whole chain. Moving a predecessor earlier never pulls its successors back. Dropping a successor onto or before its predecessor snaps it forward to the first valid position: the drop cannot create a violated arrow, while violations already present in the data are left as-is. The `Design` diamond reconverges on `Integrate`, which settles once behind the later of its two branches. `Audit` is read-only: pushing `Setup` into it leaves it in place with the violated arrow visible, and nothing beyond it moves. The all-day pair shifts by whole days and stays all-day. Dragging a terminal to close a cycle (for example `Deploy` onto `Plan`) is rejected with a transient toast. The feature has no public API yet, so the demo feeds the internal store parameters.
 
 {{"demo": "TimelineAutoScheduling.js", "bg": "inline", "defaultCodeOpen": false}}
 

packages/x-scheduler-internals-premium/src/internals/plugins/SchedulerSchedulingPlugin.ts

@@ -123,6 +123,9 @@ export class SchedulerSchedulingPlugin<
       activeDependenciesBySource: eventTimelinePremiumDependencySelectors.activeModelListBySource(
         this.store.state,
       ),
+      activeDependenciesByTarget: eventTimelinePremiumDependencySelectors.activeModelListByTarget(
+        this.store.state,
+      ),
       isEventReadOnly: (eventId) => schedulerEventSelectors.isReadOnly(this.store.state, eventId),
       updated,
       deleted: new Set(deleted),

packages/x-scheduler-internals-premium/src/internals/utils/auto-scheduling.test.ts

@@ -14,17 +14,17 @@ function buildLookup(events: SchedulerProcessedEvent[]) {
   return new Map(events.map((event) => [event.id, event]));
 }
 
-function groupBySource(dependencies: SchedulerDependency[]) {
-  const bySource = new Map<SchedulerEventId, SchedulerDependency[]>();
+function groupByEndpoint(dependencies: SchedulerDependency[], endpoint: 'source' | 'target') {
+  const grouped = new Map<SchedulerEventId, SchedulerDependency[]>();
   for (const dependency of dependencies) {
-    const group = bySource.get(dependency.source);
+    const group = grouped.get(dependency[endpoint]);
     if (group) {
       group.push(dependency);
     } else {
-      bySource.set(dependency.source, [dependency]);
+      grouped.set(dependency[endpoint], [dependency]);
     }
   }
-  return bySource;
+  return grouped;
 }
 
 let dependencyCount = 0;
@@ -47,7 +47,8 @@ function runCascade(
   return computeAutoSchedulingCascade({
     adapter,
     processedEventLookup: buildLookup(events),
-    activeDependenciesBySource: groupBySource(dependencies),
+    activeDependenciesBySource: groupByEndpoint(dependencies, 'source'),
+    activeDependenciesByTarget: groupByEndpoint(dependencies, 'target'),
     isEventReadOnly: overrides.isEventReadOnly ?? (() => false),
     updated,
     deleted: overrides.deleted ?? new Set(),
@@ -401,7 +402,7 @@ describe('computeAutoSchedulingCascade', () => {
     expect(result).to.deep.equal([]);
   });
 
-  it('should not re-emit a successor that is itself updated in the batch', () => {
+  it("should clamp an updated successor dropped before a moved predecessor's new end", () => {
     const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
     const eventB = EventBuilder.new()
       .id('b')
@@ -413,11 +414,201 @@ describe('computeAutoSchedulingCascade', () => {
       [fsDependency('a', 'b')],
       [
         { id: 'a', start: date('2025-07-03T11:00:00Z'), end: date('2025-07-03T12:00:00Z') },
-        // The user also placed b themselves, still violating: their placement wins.
+        // The user also placed b themselves, still violating: b is clamped forward.
         { id: 'b', start: date('2025-07-03T11:30:00Z'), end: date('2025-07-03T12:30:00Z') },
       ],
     );
 
+    expect(result).to.have.length(1);
+    expect(result[0].id).to.equal('b');
+    expectDates(result[0], '2025-07-03T12:00:00Z', '2025-07-03T13:00:00Z');
+  });
+
+  it('should clamp an updated successor dropped before the end of an unmoved predecessor', () => {
+    const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
+    const eventB = EventBuilder.new()
+      .id('b')
+      .span('2025-07-03T11:00:00Z', '2025-07-03T12:00:00Z')
+      .toProcessed();
+
+    const result = runCascade(
+      [eventA, eventB],
+      [fsDependency('a', 'b')],
+      [{ id: 'b', start: date('2025-07-03T09:30:00Z'), end: date('2025-07-03T10:30:00Z') }],
+    );
+
+    expect(result).to.have.length(1);
+    expect(result[0].id).to.equal('b');
+    expectDates(result[0], '2025-07-03T10:00:00Z', '2025-07-03T11:00:00Z');
+  });
+
+  it('should not clamp an updated successor dropped at a valid position', () => {
+    const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
+    const eventB = EventBuilder.new()
+      .id('b')
+      .span('2025-07-03T12:00:00Z', '2025-07-03T13:00:00Z')
+      .toProcessed();
+
+    const result = runCascade(
+      [eventA, eventB],
+      [fsDependency('a', 'b')],
+      [{ id: 'b', start: date('2025-07-03T10:00:00Z'), end: date('2025-07-03T11:00:00Z') }],
+    );
+
+    expect(result).to.deep.equal([]);
+  });
+
+  it('should cascade from the clamped position of a dropped successor', () => {
+    const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
+    const eventB = EventBuilder.new()
+      .id('b')
+      .span('2025-07-03T11:00:00Z', '2025-07-03T12:00:00Z')
+      .toProcessed();
+    const eventC = EventBuilder.new()
+      .id('c')
+      .span('2025-07-03T10:30:00Z', '2025-07-03T11:30:00Z')
+      .toProcessed();
+
+    const result = runCascade(
+      [eventA, eventB, eventC],
+      [fsDependency('a', 'b'), fsDependency('b', 'c')],
+      [{ id: 'b', start: date('2025-07-03T09:00:00Z'), end: date('2025-07-03T10:00:00Z') }],
+    );
+
+    expect(result).to.have.length(2);
+    const byId = new Map(result.map((entry) => [entry.id, entry]));
+    // b clamps to a's end, and c is pushed from b's clamped end, not its dropped one.
+    expectDates(byId.get('b')!, '2025-07-03T10:00:00Z', '2025-07-03T11:00:00Z');
+    expectDates(byId.get('c')!, '2025-07-03T11:00:00Z', '2025-07-03T12:00:00Z');
+  });
+
+  it("should clamp a dropped successor against a cascaded predecessor's new end", () => {
+    const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
+    const eventB = EventBuilder.new()
+      .id('b')
+      .span('2025-07-03T10:00:00Z', '2025-07-03T11:00:00Z')
+      .toProcessed();
+    const eventC = EventBuilder.new()
+      .id('c')
+      .span('2025-07-03T13:00:00Z', '2025-07-03T14:00:00Z')
+      .toProcessed();
+
+    const result = runCascade(
+      [eventA, eventB, eventC],
+      [fsDependency('a', 'b'), fsDependency('b', 'c')],
+      [
+        { id: 'a', start: date('2025-07-03T11:00:00Z'), end: date('2025-07-03T12:00:00Z') },
+        // c is dropped where b's *pushed* position (12:00–13:00) still overlaps it.
+        { id: 'c', start: date('2025-07-03T10:00:00Z'), end: date('2025-07-03T11:00:00Z') },
+      ],
+    );
+
+    expect(result).to.have.length(2);
+    const byId = new Map(result.map((entry) => [entry.id, entry]));
+    expectDates(byId.get('b')!, '2025-07-03T12:00:00Z', '2025-07-03T13:00:00Z');
+    expectDates(byId.get('c')!, '2025-07-03T13:00:00Z', '2025-07-03T14:00:00Z');
+  });
+
+  it('should not clamp an updated event whose start is unchanged', () => {
+    const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
+    // b arrived already violating; resizing its end does not re-position it.
+    const eventB = EventBuilder.new()
+      .id('b')
+      .span('2025-07-03T08:00:00Z', '2025-07-03T09:00:00Z')
+      .toProcessed();
+
+    const result = runCascade(
+      [eventA, eventB],
+      [fsDependency('a', 'b')],
+      [{ id: 'b', end: date('2025-07-03T09:30:00Z') }],
+    );
+
+    expect(result).to.deep.equal([]);
+  });
+
+  it('should clamp an all-day successor dropped before its predecessor by whole days', () => {
+    const predecessor = EventBuilder.new().id('a').singleDay('2025-07-04T09:00:00Z').toProcessed();
+    const successor = EventBuilder.new()
+      .id('b')
+      .withDataTimezone('UTC')
+      .span('2025-07-10T00:00:00', '2025-07-10T23:59:59.999', { allDay: true })
+      .toProcessed();
+
+    const result = runCascade(
+      [predecessor, successor],
+      [fsDependency('a', 'b')],
+      [
+        {
+          id: 'b',
+          start: utcDate('2025-07-04T00:00:00'),
+          end: utcDate('2025-07-04T23:59:59.999'),
+          allDay: true,
+        },
+      ],
+    );
+
+    expect(result).to.have.length(1);
+    // The dropped day starts before the predecessor's 10:00 end: minimal whole-day
+    // clamp from the dropped position is one day.
+    expect(adapter.getTime(result[0].start!)).to.equal(
+      adapter.getTime(utcDate('2025-07-05T00:00:00')),
+    );
+    expect(adapter.getTime(result[0].end!)).to.equal(
+      adapter.getTime(utcDate('2025-07-05T23:59:59.999')),
+    );
+  });
+
+  it('should not clamp a read-only updated event', () => {
+    const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
+    const eventB = EventBuilder.new()
+      .id('b')
+      .readOnly()
+      .span('2025-07-03T11:00:00Z', '2025-07-03T12:00:00Z')
+      .toProcessed();
+
+    const result = runCascade(
+      [eventA, eventB],
+      [fsDependency('a', 'b')],
+      [{ id: 'b', start: date('2025-07-03T09:00:00Z'), end: date('2025-07-03T10:00:00Z') }],
+      { isEventReadOnly: (eventId) => eventId === 'b' },
+    );
+
+    expect(result).to.deep.equal([]);
+  });
+
+  it('should not clamp against a predecessor deleted in the same batch', () => {
+    const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
+    const eventB = EventBuilder.new()
+      .id('b')
+      .span('2025-07-03T11:00:00Z', '2025-07-03T12:00:00Z')
+      .toProcessed();
+
+    const result = runCascade(
+      [eventA, eventB],
+      [fsDependency('a', 'b')],
+      [{ id: 'b', start: date('2025-07-03T09:00:00Z'), end: date('2025-07-03T10:00:00Z') }],
+      { deleted: new Set(['a']) },
+    );
+
+    expect(result).to.deep.equal([]);
+  });
+
+  it('should not clamp against a predecessor turning recurring in the same batch', () => {
+    const eventA = EventBuilder.new().id('a').singleDay('2025-07-03T09:00:00Z').toProcessed();
+    const eventB = EventBuilder.new()
+      .id('b')
+      .span('2025-07-03T11:00:00Z', '2025-07-03T12:00:00Z')
+      .toProcessed();
+
+    const result = runCascade(
+      [eventA, eventB],
+      [fsDependency('a', 'b')],
+      [
+        { id: 'a', rrule: { freq: 'DAILY', interval: 1 } },
+        { id: 'b', start: date('2025-07-03T09:00:00Z'), end: date('2025-07-03T10:00:00Z') },
+      ],
+    );
+
     expect(result).to.deep.equal([]);
   });