gantt-lib 0.127.0 → 0.128.0

package/dist/core/scheduling/index.mjs

@@ -1357,6 +1357,1127 @@ function validateDependencies(tasks) {
     errors
   };
 }
+
+// src/core/scheduling/subtreeScaling.ts
+function toIsoDate2(date) {
+  return date.toISOString().split("T")[0];
+}
+function isoOfTaskDate(date) {
+  return toIsoDate2(parseDateOnly(date));
+}
+function scaleFailure(code, details) {
+  return details && details.length > 0 ? { ok: false, code, changedTasks: [], changedIds: [], details } : { ok: false, code, changedTasks: [], changedIds: [] };
+}
+function isFiniteInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+}
+function dependencyLag(dep) {
+  return Number.isFinite(dep.lag) ? dep.lag : 0;
+}
+function createSolveSpace(mirrored, anchorDate, businessDays, weekendPredicate) {
+  const space = {
+    mirrored,
+    anchorDate,
+    businessDays,
+    weekendPredicate,
+    idxCache: /* @__PURE__ */ new Map(),
+    idxOf(date) {
+      const key = toIsoDate2(date);
+      const cached = space.idxCache.get(key);
+      if (cached !== void 0) {
+        return cached;
+      }
+      let idx;
+      if (businessDays && weekendPredicate) {
+        idx = mirrored ? getBusinessDayOffset(date, anchorDate, weekendPredicate) : getBusinessDayOffset(anchorDate, date, weekendPredicate);
+      } else {
+        const deltaMs = date.getTime() - anchorDate.getTime();
+        idx = mirrored ? -Math.round(deltaMs / DAY_MS) : Math.round(deltaMs / DAY_MS);
+      }
+      space.idxCache.set(key, idx);
+      return idx;
+    },
+    dateOf(idx) {
+      if (businessDays && weekendPredicate) {
+        return shiftBusinessDayOffset(anchorDate, mirrored ? -idx : idx, weekendPredicate);
+      }
+      const delta = mirrored ? -idx : idx;
+      return new Date(anchorDate.getTime() + delta * DAY_MS);
+    }
+  };
+  return space;
+}
+function validateScaleInput(parentId, targetDuration, snapshot, businessDays, weekendPredicate) {
+  if (!isFiniteInteger(targetDuration) || targetDuration < 1) {
+    return { ok: false, code: "INVALID_TARGET_DURATION", details: [`targetDuration=${String(targetDuration)}`] };
+  }
+  const taskById = /* @__PURE__ */ new Map();
+  const duplicateIds = [];
+  for (const task of snapshot) {
+    if (taskById.has(task.id)) duplicateIds.push(task.id);
+    taskById.set(task.id, task);
+  }
+  if (duplicateIds.length > 0) {
+    return { ok: false, code: "INVALID_HIERARCHY", details: [`duplicate task ids: ${duplicateIds.slice(0, 5).join(", ")}`] };
+  }
+  const parentTask = taskById.get(parentId);
+  if (!parentTask) {
+    return { ok: false, code: "TASK_NOT_FOUND", details: [`parentId=${parentId}`] };
+  }
+  const hasChild = snapshot.some((task) => task.parentId === parentId);
+  if (!hasChild) {
+    return { ok: false, code: "NOT_A_PARENT", details: [`task ${parentId} has no children`] };
+  }
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  const hierarchyErrors = [];
+  for (const task of snapshot) {
+    if (!task.parentId) continue;
+    if (task.parentId === task.id) {
+      hierarchyErrors.push(`self-parent: ${task.id}`);
+      continue;
+    }
+    if (!taskById.has(task.parentId)) {
+      hierarchyErrors.push(`missing parent ${task.parentId} for ${task.id}`);
+      continue;
+    }
+    const children = childrenByParentId.get(task.parentId) ?? [];
+    children.push(task);
+    childrenByParentId.set(task.parentId, children);
+  }
+  if (hierarchyErrors.length === 0) {
+    const globallyVisited = /* @__PURE__ */ new Set();
+    for (const task of snapshot) {
+      if (globallyVisited.has(task.id)) continue;
+      const chain = /* @__PURE__ */ new Set();
+      let current = task;
+      while (current?.parentId) {
+        if (chain.has(current.id)) {
+          hierarchyErrors.push(`hierarchy cycle at ${current.id}`);
+          break;
+        }
+        chain.add(current.id);
+        globallyVisited.add(current.id);
+        current = taskById.get(current.parentId);
+      }
+    }
+  }
+  if (hierarchyErrors.length > 0) {
+    return { ok: false, code: "INVALID_HIERARCHY", details: hierarchyErrors.slice(0, 5) };
+  }
+  const subtreeIds = collectSubtreeIds(parentId, childrenByParentId);
+  const participating = new Set(subtreeIds);
+  participating.add(parentId);
+  for (const task of snapshot) {
+    const isInternal = subtreeIds.has(task.id) || task.id === parentId;
+    for (const dep of task.dependencies ?? []) {
+      if (isInternal) participating.add(dep.taskId);
+      if (subtreeIds.has(dep.taskId) || dep.taskId === parentId) participating.add(task.id);
+    }
+  }
+  const dateErrors = [];
+  for (const id of participating) {
+    const task = taskById.get(id);
+    if (!task) continue;
+    const start = parseDateOnly(task.startDate);
+    const end = parseDateOnly(task.endDate);
+    if (!Number.isFinite(start.getTime()) || !Number.isFinite(end.getTime())) {
+      dateErrors.push(`unparseable dates on ${id}`);
+      continue;
+    }
+    if (end.getTime() < start.getTime()) {
+      dateErrors.push(`endDate before startDate on ${id}`);
+      continue;
+    }
+    if (!subtreeIds.has(id)) continue;
+    if (task.type === "milestone" && start.getTime() !== end.getTime()) {
+      dateErrors.push(`milestone ${id} must have equal start and end dates`);
+      continue;
+    }
+    if (businessDays && weekendPredicate && !childrenByParentId.has(task.id)) {
+      if (weekendPredicate(start) || weekendPredicate(end)) {
+        dateErrors.push(`leaf ${id} boundary falls on a weekend in business-day mode`);
+      }
+    }
+  }
+  if (dateErrors.length > 0) {
+    return { ok: false, code: "INVALID_DATES", details: dateErrors.slice(0, 5) };
+  }
+  const depValidation = validateDependencies(snapshot);
+  if (!depValidation.isValid) {
+    return {
+      ok: false,
+      code: "INVALID_DEPENDENCIES",
+      details: depValidation.errors.slice(0, 5).map((error) => `${error.type}: ${error.taskId}`)
+    };
+  }
+  return { ok: true, parentTask };
+}
+function collectSubtreeIds(parentId, childrenByParentId) {
+  const subtreeIds = /* @__PURE__ */ new Set();
+  const queue = [parentId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const child of childrenByParentId.get(current) ?? []) {
+      if (subtreeIds.has(child.id)) continue;
+      subtreeIds.add(child.id);
+      queue.push(child.id);
+    }
+  }
+  return subtreeIds;
+}
+var PARENT_BOUND_KEY = "__parent_bound__";
+function buildScaleContext(parentTask, snapshot, options) {
+  const businessDays = options.businessDays ?? false;
+  const weekendPredicate = options.weekendPredicate;
+  const isImmutable = options.isImmutable ?? ((task) => task.locked === true);
+  const indexedSnapshot = snapshot.map((task, index) => ({ task, index }));
+  const taskById = new Map(indexedSnapshot.map(({ task }) => [task.id, task]));
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  for (const task of snapshot) {
+    if (!task.parentId) continue;
+    const children = childrenByParentId.get(task.parentId) ?? [];
+    children.push(task);
+    childrenByParentId.set(task.parentId, children);
+  }
+  const subtreeIds = collectSubtreeIds(parentTask.id, childrenByParentId);
+  const depthById = /* @__PURE__ */ new Map([[parentTask.id, 0]]);
+  const depthQueue = [parentTask.id];
+  while (depthQueue.length > 0) {
+    const current = depthQueue.shift();
+    const depth = depthById.get(current) ?? 0;
+    for (const child of childrenByParentId.get(current) ?? []) {
+      depthById.set(child.id, depth + 1);
+      depthQueue.push(child.id);
+    }
+  }
+  const subtreeTasks = indexedSnapshot.filter(({ task }) => subtreeIds.has(task.id));
+  const leavesRaw = subtreeTasks.filter(({ task }) => !childrenByParentId.has(task.id));
+  const nestedParentsRaw = subtreeTasks.filter(
+    ({ task }) => childrenByParentId.has(task.id) && task.id !== parentTask.id
+  );
+  const leafEntries = leavesRaw.map(({ task, index }) => {
+    const start = parseDateOnly(task.startDate);
+    const end = parseDateOnly(task.endDate);
+    return { task, index, start, end };
+  });
+  const computedStart = new Date(Math.min(...leafEntries.map((entry) => entry.start.getTime())));
+  const computedEnd = new Date(Math.max(...leafEntries.map((entry) => entry.end.getTime())));
+  const mirrored = (options.anchor ?? "start") === "end";
+  const anchorDate = mirrored ? computedEnd : computedStart;
+  const space = createSolveSpace(mirrored, anchorDate, businessDays, weekendPredicate);
+  let lo = Number.POSITIVE_INFINITY;
+  let hi = Number.NEGATIVE_INFINITY;
+  for (const entry of leafEntries) {
+    lo = Math.min(lo, space.idxOf(entry.start), space.idxOf(entry.end));
+    hi = Math.max(hi, space.idxOf(entry.start), space.idxOf(entry.end));
+  }
+  const originalSpan = Number.isFinite(lo) ? hi - lo + 1 : 1;
+  const immutableById = /* @__PURE__ */ new Map();
+  for (const { task } of subtreeTasks) {
+    immutableById.set(task.id, isImmutable(task) === true);
+  }
+  const getMinDuration = options.getMinDuration;
+  const minDurationErrors = [];
+  const minDurationById = /* @__PURE__ */ new Map();
+  for (const { task } of subtreeTasks) {
+    if (childrenByParentId.has(task.id)) continue;
+    if (task.type === "milestone") {
+      minDurationById.set(task.id, 0);
+      continue;
+    }
+    let min = 1;
+    if (getMinDuration) {
+      const requested = getMinDuration(task);
+      if (!isFiniteInteger(requested) || requested < 0) {
+        minDurationErrors.push(`getMinDuration(${task.id}) = ${String(requested)}`);
+        continue;
+      }
+      min = Math.max(1, requested);
+    }
+    minDurationById.set(task.id, min);
+  }
+  if (minDurationErrors.length > 0) {
+    return { ok: false, code: "INVALID_MINIMUM", details: minDurationErrors.slice(0, 5) };
+  }
+  const leaves = leafEntries.map(({ task, index, start, end }) => ({
+    id: task.id,
+    task,
+    snapshotIndex: index,
+    depth: depthById.get(task.id) ?? 1,
+    isMilestone: task.type === "milestone",
+    immutable: immutableById.get(task.id) === true,
+    startIdx: space.idxOf(start),
+    endIdx: space.idxOf(end),
+    duration: getTaskDuration(start, end, businessDays, weekendPredicate),
+    minDuration: minDurationById.get(task.id) ?? 1,
+    componentId: -1,
+    isRoot: false
+  }));
+  const leafById = new Map(leaves.map((leaf) => [leaf.id, leaf]));
+  const anchorLeafByParent = /* @__PURE__ */ new Map();
+  const nestedParents = nestedParentsRaw.map(({ task, index }) => ({ task, snapshotIndex: index, depth: depthById.get(task.id) ?? 1 })).sort((left, right) => right.depth - left.depth || left.snapshotIndex - right.snapshotIndex);
+  for (const { task } of nestedParents) {
+    let earliestStart = null;
+    let latestEnd = null;
+    for (const leaf of leaves) {
+      if (!isDescendantOf(leaf.task, task.id, taskById)) continue;
+      if (!earliestStart || leaf.startIdx < earliestStart.startIdx) earliestStart = leaf;
+      if (!latestEnd || leaf.endIdx > latestEnd.endIdx) latestEnd = leaf;
+    }
+    if (earliestStart && latestEnd) {
+      anchorLeafByParent.set(task.id, { earliestStartId: earliestStart.id, latestEndId: latestEnd.id });
+    }
+  }
+  const getMinLag = options.getMinLag;
+  const edges = [];
+  const boundsByLeaf = /* @__PURE__ */ new Map();
+  const outgoingRefs = [];
+  const lagErrors = [];
+  const pushEdge = (ownerTask, dep, depIndex, predLeafId, succLeafId) => {
+    const originalLag = dependencyLag(dep);
+    const succLeaf = leafById.get(succLeafId);
+    const adjustable = originalLag > 0 && !!succLeaf && !succLeaf.immutable && !immutableById.get(ownerTask.id);
+    let minLag = originalLag;
+    if (adjustable) {
+      minLag = 0;
+      if (getMinLag) {
+        const requested = getMinLag(dep, ownerTask);
+        if (!isFiniteInteger(requested) || requested < 0 || requested > originalLag) {
+          lagErrors.push(`getMinLag(${ownerTask.id}#${depIndex}) = ${String(requested)}`);
+        } else {
+          minLag = requested;
+        }
+      }
+    }
+    edges.push({
+      key: `${ownerTask.id}#${depIndex}`,
+      predLeafId,
+      succLeafId,
+      type: dep.type,
+      originalLag,
+      minLag,
+      adjustable
+    });
+  };
+  for (const { task } of subtreeTasks) {
+    if (!task.dependencies) continue;
+    task.dependencies.forEach((dep, depIndex) => {
+      const predTask = taskById.get(dep.taskId);
+      if (!predTask) return;
+      const predInside = subtreeIds.has(predTask.id);
+      const isOwnerLeaf = leafById.has(task.id);
+      if (!predInside) {
+        if (isOwnerLeaf) {
+          const bounds = boundsByLeaf.get(task.id) ?? [];
+          bounds.push({ leafId: task.id, type: dep.type, lag: dependencyLag(dep), predTask });
+          boundsByLeaf.set(task.id, bounds);
+        } else if (task.id === parentTask.id) {
+          if (dep.type === "FS" || dep.type === "SS") {
+            const bounds = boundsByLeaf.get(PARENT_BOUND_KEY) ?? [];
+            bounds.push({ leafId: PARENT_BOUND_KEY, type: dep.type, lag: dependencyLag(dep), predTask });
+            boundsByLeaf.set(PARENT_BOUND_KEY, bounds);
+          }
+        } else {
+          const anchors = anchorLeafByParent.get(task.id);
+          if (anchors) {
+            const targetLeafId = dep.type === "FS" || dep.type === "SS" ? anchors.earliestStartId : anchors.latestEndId;
+            const bounds = boundsByLeaf.get(targetLeafId) ?? [];
+            bounds.push({ leafId: targetLeafId, type: dep.type, lag: dependencyLag(dep), predTask });
+            boundsByLeaf.set(targetLeafId, bounds);
+          }
+        }
+        return;
+      }
+      let predLeafId;
+      if (leafById.has(predTask.id)) {
+        predLeafId = predTask.id;
+      } else {
+        const anchors = anchorLeafByParent.get(predTask.id);
+        if (anchors) {
+          predLeafId = dep.type === "FS" || dep.type === "FF" ? anchors.latestEndId : anchors.earliestStartId;
+        }
+      }
+      let succLeafId;
+      if (isOwnerLeaf) {
+        succLeafId = task.id;
+      } else {
+        const anchors = anchorLeafByParent.get(task.id);
+        if (anchors) {
+          succLeafId = dep.type === "FS" || dep.type === "SS" ? anchors.earliestStartId : anchors.latestEndId;
+        }
+      }
+      if (predLeafId && succLeafId && predLeafId !== succLeafId) {
+        pushEdge(task, dep, depIndex, predLeafId, succLeafId);
+      }
+    });
+  }
+  if (lagErrors.length > 0) {
+    return { ok: false, code: "INVALID_MINIMUM", details: lagErrors.slice(0, 5) };
+  }
+  for (const task of snapshot) {
+    if (subtreeIds.has(task.id) || task.id === parentTask.id) continue;
+    if (!task.dependencies) continue;
+    for (const dep of task.dependencies) {
+      if (!subtreeIds.has(dep.taskId) && dep.taskId !== parentTask.id) continue;
+      outgoingRefs.push({ fromId: dep.taskId, succTask: task, type: dep.type, lag: dependencyLag(dep) });
+    }
+  }
+  const inEdges = /* @__PURE__ */ new Map();
+  const outEdges = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const inList = inEdges.get(edge.succLeafId) ?? [];
+    inList.push(edge);
+    inEdges.set(edge.succLeafId, inList);
+    const outList = outEdges.get(edge.predLeafId) ?? [];
+    outList.push(edge);
+    outEdges.set(edge.predLeafId, outList);
+  }
+  for (const leaf of leaves) {
+    leaf.isRoot = (inEdges.get(leaf.id)?.length ?? 0) === 0;
+  }
+  const componentRoot = new Map(leaves.map((leaf) => [leaf.id, leaf.id]));
+  const find = (id) => {
+    let root = componentRoot.get(id) ?? id;
+    if (root === id) return root;
+    root = find(root);
+    componentRoot.set(id, root);
+    return root;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) componentRoot.set(ra, rb);
+  };
+  for (const edge of edges) union(edge.predLeafId, edge.succLeafId);
+  const componentIdByRoot = /* @__PURE__ */ new Map();
+  let componentCount = 0;
+  for (const leaf of leaves) {
+    const root = find(leaf.id);
+    if (!componentIdByRoot.has(root)) {
+      componentIdByRoot.set(root, componentCount);
+      componentCount++;
+    }
+    leaf.componentId = componentIdByRoot.get(root);
+  }
+  const componentFloor = /* @__PURE__ */ new Map();
+  const parentBounds = boundsByLeaf.get(PARENT_BOUND_KEY) ?? [];
+  for (const bound of parentBounds) {
+    const { predStart, predEnd } = normalizePredecessorDates(bound.predTask, parseDateOnly);
+    const boundDate = calculateSuccessorDate(
+      predStart,
+      predEnd,
+      bound.type,
+      bound.lag,
+      businessDays,
+      weekendPredicate
+    );
+    const boundIdx = space.idxOf(boundDate);
+    for (const leaf of leaves) {
+      if (!leaf.isRoot || leaf.immutable) continue;
+      componentFloor.set(leaf.componentId, Math.max(componentFloor.get(leaf.componentId) ?? 0, boundIdx));
+    }
+  }
+  boundsByLeaf.delete(PARENT_BOUND_KEY);
+  let adjustableTotal = 0;
+  for (const leaf of leaves) {
+    if (leaf.immutable || leaf.isMilestone) continue;
+    adjustableTotal += Math.max(0, leaf.duration - leaf.minDuration);
+  }
+  for (const edge of edges) {
+    if (edge.adjustable && edge.originalLag > edge.minLag) {
+      adjustableTotal += edge.originalLag - edge.minLag;
+    }
+  }
+  for (const leaf of leaves) {
+    if (leaf.isRoot && !leaf.immutable) adjustableTotal += Math.max(0, leaf.startIdx);
+  }
+  const maxCorrectionSteps = 2 * (adjustableTotal + originalSpan) + targetBudgetGuard(originalSpan) + 64;
+  const context = {
+    businessDays,
+    weekendPredicate,
+    mirrored,
+    parentTask,
+    snapshot,
+    subtreeIds,
+    childrenByParentId,
+    leaves,
+    leafById,
+    nestedParents,
+    edges,
+    inEdges,
+    outEdges,
+    boundsByLeaf,
+    outgoingRefs,
+    componentFloor,
+    originalSpan,
+    maxCorrectionSteps,
+    isImmutable
+  };
+  return { ok: true, context, space };
+}
+function targetBudgetGuard(originalSpan) {
+  return Math.max(1, originalSpan) * 2;
+}
+function isDescendantOf(task, ancestorId, taskById) {
+  const visited = /* @__PURE__ */ new Set();
+  let currentId = task.parentId;
+  while (currentId) {
+    if (currentId === ancestorId) return true;
+    if (visited.has(currentId)) return false;
+    visited.add(currentId);
+    currentId = taskById.get(currentId)?.parentId;
+  }
+  return false;
+}
+function topoOrderLeaves(ctx, componentLeaves) {
+  const byId = new Map(componentLeaves.map((leaf) => [leaf.id, leaf]));
+  const indegree = new Map(
+    componentLeaves.map((leaf) => [leaf.id, 0])
+  );
+  for (const leaf of componentLeaves) {
+    for (const edge of ctx.inEdges.get(leaf.id) ?? []) {
+      if (byId.has(edge.predLeafId)) {
+        indegree.set(leaf.id, (indegree.get(leaf.id) ?? 0) + 1);
+      }
+    }
+  }
+  const ready = componentLeaves.filter((leaf) => (indegree.get(leaf.id) ?? 0) === 0).sort((left, right) => left.snapshotIndex - right.snapshotIndex);
+  const ordered = [];
+  const emitted = /* @__PURE__ */ new Set();
+  while (ready.length > 0) {
+    const current = ready.shift();
+    ordered.push(current);
+    emitted.add(current.id);
+    for (const edge of ctx.outEdges.get(current.id) ?? []) {
+      if (!byId.has(edge.succLeafId) || emitted.has(edge.succLeafId)) continue;
+      const next = (indegree.get(edge.succLeafId) ?? 0) - 1;
+      indegree.set(edge.succLeafId, next);
+      if (next === 0) {
+        ready.push(byId.get(edge.succLeafId));
+        ready.sort((left, right) => left.snapshotIndex - right.snapshotIndex);
+      }
+    }
+  }
+  for (const leaf of componentLeaves) {
+    if (!emitted.has(leaf.id)) ordered.push(leaf);
+  }
+  return ordered;
+}
+function evaluateLayout(ctx, space, state) {
+  const { businessDays, weekendPredicate } = ctx;
+  const dates = /* @__PURE__ */ new Map();
+  for (const leaf of ctx.leaves) {
+    if (leaf.immutable) {
+      dates.set(leaf.id, {
+        start: parseDateOnly(leaf.task.startDate),
+        end: parseDateOnly(leaf.task.endDate)
+      });
+    }
+  }
+  const componentOrder = [];
+  const componentLeaves = /* @__PURE__ */ new Map();
+  for (const leaf of ctx.leaves) {
+    const list = componentLeaves.get(leaf.componentId) ?? [];
+    list.push(leaf);
+    componentLeaves.set(leaf.componentId, list);
+    if (list.length === 1) componentOrder.push(leaf.componentId);
+  }
+  for (const componentId of componentOrder) {
+    const members = componentLeaves.get(componentId) ?? [];
+    const order = topoOrderLeaves(ctx, members);
+    for (const leaf of order) {
+      if (dates.has(leaf.id)) continue;
+      const duration = state.durations.get(leaf.id) ?? leaf.duration;
+      let range = null;
+      const incoming = ctx.inEdges.get(leaf.id) ?? [];
+      if (incoming.length === 0) {
+        const floor = ctx.componentFloor.get(leaf.componentId) ?? 0;
+        const offset = Math.max(floor, state.offsets.get(leaf.id) ?? leaf.startIdx);
+        range = buildTaskRangeFromStart(space.dateOf(offset), duration, businessDays, weekendPredicate);
+      } else {
+        for (const edge of incoming) {
+          const predDates = dates.get(edge.predLeafId);
+          if (!predDates) continue;
+          const predLeaf = ctx.leafById.get(edge.predLeafId);
+          const { predStart, predEnd } = normalizePredecessorDates(
+            {
+              startDate: predDates.start,
+              endDate: predDates.end,
+              type: predLeaf?.isMilestone ? "milestone" : "task"
+            },
+            parseDateOnly
+          );
+          const lag = state.lags.get(edge.key) ?? edge.originalLag;
+          const constraint = calculateSuccessorDate(
+            predStart,
+            predEnd,
+            edge.type,
+            lag,
+            businessDays,
+            weekendPredicate,
+            leaf.isMilestone ? "milestone" : void 0
+          );
+          const candidate = edge.type === "FS" || edge.type === "SS" ? buildTaskRangeFromStart(constraint, duration, businessDays, weekendPredicate) : buildTaskRangeFromEnd(constraint, duration, businessDays, weekendPredicate);
+          if (!range || candidate.start.getTime() > range.start.getTime() || candidate.start.getTime() === range.start.getTime() && candidate.end.getTime() > range.end.getTime()) {
+            range = candidate;
+          }
+        }
+      }
+      if (!range) {
+        range = buildTaskRangeFromStart(space.dateOf(leaf.startIdx), duration, businessDays, weekendPredicate);
+      }
+      for (const bound of ctx.boundsByLeaf.get(leaf.id) ?? []) {
+        const { predStart, predEnd } = normalizePredecessorDates(bound.predTask, parseDateOnly);
+        const boundDate = calculateSuccessorDate(
+          predStart,
+          predEnd,
+          bound.type,
+          bound.lag,
+          businessDays,
+          weekendPredicate,
+          leaf.isMilestone ? "milestone" : void 0
+        );
+        if ((bound.type === "FS" || bound.type === "SS") && range.start.getTime() < boundDate.getTime()) {
+          range = buildTaskRangeFromStart(boundDate, duration, businessDays, weekendPredicate);
+        } else if ((bound.type === "FF" || bound.type === "SF") && range.end.getTime() < boundDate.getTime()) {
+          range = buildTaskRangeFromEnd(boundDate, duration, businessDays, weekendPredicate);
+        }
+      }
+      for (const edge of ctx.outEdges.get(leaf.id) ?? []) {
+        const succLeaf = ctx.leafById.get(edge.succLeafId);
+        if (!succLeaf || !succLeaf.immutable) continue;
+        const succDates = dates.get(succLeaf.id);
+        if (!succDates) continue;
+        const lag = state.lags.get(edge.key) ?? edge.originalLag;
+        range = applyReverseBound(
+          range,
+          edge.type,
+          lag,
+          succDates,
+          succLeaf.isMilestone,
+          duration,
+          businessDays,
+          weekendPredicate
+        );
+      }
+      range = clampToAnchor(range, space, duration, businessDays, weekendPredicate);
+      dates.set(leaf.id, range);
+    }
+  }
+  let lo = Number.POSITIVE_INFINITY;
+  let hi = Number.NEGATIVE_INFINITY;
+  for (const leaf of ctx.leaves) {
+    const range = dates.get(leaf.id);
+    if (!range) continue;
+    const startIdx = space.idxOf(range.start);
+    const endIdx = space.idxOf(range.end);
+    lo = Math.min(lo, startIdx, endIdx);
+    hi = Math.max(hi, startIdx, endIdx);
+  }
+  if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
+    return { dates, lo: 0, hi: 0, span: 1 };
+  }
+  return { dates, lo, hi, span: hi - lo + 1 };
+}
+function applyReverseBound(range, type, lag, succDates, succIsMilestone, duration, businessDays, weekendPredicate) {
+  const shiftBack = (date, days) => businessDays && weekendPredicate ? shiftBusinessDayOffset(date, -days, weekendPredicate) : new Date(date.getTime() - days * DAY_MS);
+  switch (type) {
+    case "FS": {
+      const allowedEnd = shiftBack(succDates.start, lag + (succIsMilestone ? 0 : 1));
+      return range.end.getTime() > allowedEnd.getTime() ? buildTaskRangeFromEnd(allowedEnd, duration, businessDays, weekendPredicate) : range;
+    }
+    case "SS": {
+      const allowedStart = shiftBack(succDates.start, lag);
+      return range.start.getTime() > allowedStart.getTime() ? buildTaskRangeFromStart(allowedStart, duration, businessDays, weekendPredicate) : range;
+    }
+    case "FF": {
+      const allowedEnd = shiftBack(succDates.end, lag);
+      return range.end.getTime() > allowedEnd.getTime() ? buildTaskRangeFromEnd(allowedEnd, duration, businessDays, weekendPredicate) : range;
+    }
+    case "SF": {
+      const allowedStart = shiftBack(succDates.end, lag - 1);
+      return range.start.getTime() > allowedStart.getTime() ? buildTaskRangeFromStart(allowedStart, duration, businessDays, weekendPredicate) : range;
+    }
+  }
+}
+function clampToAnchor(range, space, duration, businessDays, weekendPredicate) {
+  if (!space.mirrored) {
+    if (space.idxOf(range.start) < 0) {
+      return buildTaskRangeFromStart(space.anchorDate, duration, businessDays, weekendPredicate);
+    }
+  } else if (space.idxOf(range.end) < 0) {
+    return buildTaskRangeFromEnd(space.anchorDate, duration, businessDays, weekendPredicate);
+  }
+  return range;
+}
+function allocateDurations(ctx, target) {
+  const durations = /* @__PURE__ */ new Map();
+  const ratio = target / Math.max(1, ctx.originalSpan);
+  for (const leaf of ctx.leaves) {
+    if (leaf.immutable || leaf.isMilestone) {
+      durations.set(leaf.id, leaf.duration);
+    }
+  }
+  const ideals = ctx.leaves.filter((leaf) => !leaf.immutable && !leaf.isMilestone).map((leaf) => ({ leaf, ideal: Math.max(leaf.minDuration, leaf.duration * ratio) }));
+  const minTotal = ideals.reduce((sum, { leaf }) => sum + leaf.minDuration, 0);
+  const idealTotal = ideals.reduce((sum, { ideal }) => sum + ideal, 0);
+  const total = Math.max(minTotal, Math.round(idealTotal));
+  const floors = /* @__PURE__ */ new Map();
+  let floorTotal = 0;
+  for (const { leaf, ideal } of ideals) {
+    const floor = Math.max(leaf.minDuration, Math.floor(ideal));
+    floors.set(leaf.id, floor);
+    floorTotal += floor;
+  }
+  let remaining = Math.max(0, total - floorTotal);
+  const byFraction = [...ideals].sort((left, right) => {
+    const fracLeft = left.ideal - (floors.get(left.leaf.id) ?? 0);
+    const fracRight = right.ideal - (floors.get(right.leaf.id) ?? 0);
+    if (fracLeft !== fracRight) return fracRight - fracLeft;
+    const timeLeft = isoOfTaskDate(left.leaf.task.startDate);
+    const timeRight = isoOfTaskDate(right.leaf.task.startDate);
+    if (timeLeft !== timeRight) return timeLeft < timeRight ? -1 : 1;
+    return left.leaf.id < right.leaf.id ? -1 : 1;
+  });
+  for (const { leaf } of byFraction) {
+    if (remaining <= 0) break;
+    floors.set(leaf.id, (floors.get(leaf.id) ?? 0) + 1);
+    remaining -= 1;
+  }
+  for (const { leaf } of ideals) {
+    durations.set(leaf.id, floors.get(leaf.id) ?? leaf.duration);
+  }
+  return durations;
+}
+function solveScale(ctx, space, target) {
+  const state = {
+    durations: allocateDurations(ctx, target),
+    lags: new Map(ctx.edges.map((edge) => [edge.key, edge.originalLag])),
+    offsets: new Map(
+      ctx.leaves.filter((leaf) => leaf.isRoot && !leaf.immutable).map((leaf) => {
+        const floor = ctx.componentFloor.get(leaf.componentId) ?? 0;
+        const scaled = Math.round(leaf.startIdx * target / Math.max(1, ctx.originalSpan));
+        return [leaf.id, Math.max(floor, scaled)];
+      })
+    )
+  };
+  let layout = evaluateLayout(ctx, space, state);
+  let exhausted = false;
+  let steps = 0;
+  while (layout.span !== target && steps < ctx.maxCorrectionSteps) {
+    steps++;
+    if (layout.span > target) {
+      if (tryFirstImprovementReduce(ctx, space, state, layout)) {
+        layout = evaluateLayout(ctx, space, state);
+        continue;
+      }
+      if (exhausted) break;
+      exhausted = true;
+      exhaustFlexibleGaps(ctx, state);
+      layout = evaluateLayout(ctx, space, state);
+      continue;
+    }
+    if (tryGrow(ctx, space, state, layout, target)) {
+      layout = evaluateLayout(ctx, space, state);
+      continue;
+    }
+    break;
+  }
+  layout = alignAnchorBoundary(ctx, space, state, layout);
+  return {
+    state,
+    layout,
+    appliedSpan: layout.span,
+    clamped: layout.span > target
+  };
+}
+function farBoundaryKey(leaf, dates, space) {
+  const range = dates.get(leaf.id);
+  if (!range) return Math.max(leaf.startIdx, leaf.endIdx);
+  return Math.max(space.idxOf(range.start), space.idxOf(range.end));
+}
+function tryFirstImprovementReduce(ctx, space, state, layout) {
+  const durationCandidates = ctx.leaves.filter(
+    (leaf) => !leaf.immutable && !leaf.isMilestone && (state.durations.get(leaf.id) ?? leaf.duration) > leaf.minDuration
+  ).sort(
+    (left, right) => farBoundaryKey(right, layout.dates, space) - farBoundaryKey(left, layout.dates, space) || left.snapshotIndex - right.snapshotIndex
+  );
+  for (const leaf of durationCandidates) {
+    const current = state.durations.get(leaf.id) ?? leaf.duration;
+    state.durations.set(leaf.id, current - 1);
+    const next = evaluateLayout(ctx, space, state);
+    if (next.span < layout.span) return true;
+    state.durations.set(leaf.id, current);
+  }
+  const lagCandidates = ctx.edges.filter((edge) => edge.adjustable && (state.lags.get(edge.key) ?? edge.originalLag) > edge.minLag).sort((left, right) => {
+    const succLeft = ctx.leafById.get(left.succLeafId)?.snapshotIndex ?? 0;
+    const succRight = ctx.leafById.get(right.succLeafId)?.snapshotIndex ?? 0;
+    if (succLeft !== succRight) return succLeft - succRight;
+    return left.key < right.key ? -1 : 1;
+  });
+  for (const edge of lagCandidates) {
+    const current = state.lags.get(edge.key) ?? edge.originalLag;
+    state.lags.set(edge.key, current - 1);
+    const next = evaluateLayout(ctx, space, state);
+    if (next.span < layout.span) return true;
+    state.lags.set(edge.key, current);
+  }
+  const offsetCandidates = ctx.leaves.filter((leaf) => leaf.isRoot && !leaf.immutable).map((leaf) => ({ leaf, offset: state.offsets.get(leaf.id) ?? leaf.startIdx })).filter(({ leaf, offset }) => offset > (ctx.componentFloor.get(leaf.componentId) ?? 0)).sort(
+    (left, right) => right.offset - left.offset || left.leaf.snapshotIndex - right.leaf.snapshotIndex
+  );
+  for (const { leaf, offset } of offsetCandidates) {
+    state.offsets.set(leaf.id, offset - 1);
+    const next = evaluateLayout(ctx, space, state);
+    if (next.span < layout.span) return true;
+    state.offsets.set(leaf.id, offset);
+  }
+  return false;
+}
+function exhaustFlexibleGaps(ctx, state) {
+  for (const leaf of ctx.leaves) {
+    if (leaf.immutable || leaf.isMilestone) continue;
+    state.durations.set(leaf.id, leaf.minDuration);
+  }
+  for (const edge of ctx.edges) {
+    if (edge.adjustable) {
+      state.lags.set(edge.key, edge.minLag);
+    }
+  }
+  for (const leaf of ctx.leaves) {
+    if (!leaf.isRoot || leaf.immutable) continue;
+    state.offsets.set(leaf.id, ctx.componentFloor.get(leaf.componentId) ?? 0);
+  }
+}
+function tryGrow(ctx, space, state, layout, target) {
+  const growthCandidates = ctx.leaves.filter((leaf) => !leaf.immutable && !leaf.isMilestone).sort(
+    (left, right) => farBoundaryKey(right, layout.dates, space) - farBoundaryKey(left, layout.dates, space) || left.snapshotIndex - right.snapshotIndex
+  );
+  for (const leaf of growthCandidates) {
+    const current = state.durations.get(leaf.id) ?? leaf.duration;
+    state.durations.set(leaf.id, current + 1);
+    const next = evaluateLayout(ctx, space, state);
+    if (next.span > layout.span && next.span <= target) return true;
+    state.durations.set(leaf.id, current);
+  }
+  const offsetCandidates = ctx.leaves.filter((leaf) => leaf.isRoot && !leaf.immutable).map((leaf) => ({ leaf, offset: state.offsets.get(leaf.id) ?? leaf.startIdx })).sort(
+    (left, right) => right.offset - left.offset || left.leaf.snapshotIndex - right.leaf.snapshotIndex
+  );
+  for (const { leaf, offset } of offsetCandidates) {
+    state.offsets.set(leaf.id, offset + 1);
+    const next = evaluateLayout(ctx, space, state);
+    if (next.span > layout.span && next.span <= target) return true;
+    state.offsets.set(leaf.id, offset);
+  }
+  return false;
+}
+function alignAnchorBoundary(ctx, space, state, layout) {
+  if (layout.lo === 0) return layout;
+  if (ctx.leaves.some((leaf) => leaf.immutable)) return layout;
+  if (ctx.boundsByLeaf.size > 0) return layout;
+  if (ctx.componentFloor.size > 0) return layout;
+  const roots = ctx.leaves.filter((leaf) => leaf.isRoot && !leaf.immutable);
+  if (roots.length === 0) return layout;
+  const minOffset = Math.min(
+    ...roots.map((leaf) => state.offsets.get(leaf.id) ?? leaf.startIdx)
+  );
+  if (minOffset <= 0) return layout;
+  const shift = Math.min(layout.lo, minOffset);
+  if (shift <= 0) return layout;
+  const backup = new Map(state.offsets);
+  for (const leaf of roots) {
+    state.offsets.set(leaf.id, (state.offsets.get(leaf.id) ?? leaf.startIdx) - shift);
+  }
+  const next = evaluateLayout(ctx, space, state);
+  if (next.span === layout.span && next.lo < layout.lo) {
+    return next;
+  }
+  state.offsets.clear();
+  for (const [key, value] of backup) state.offsets.set(key, value);
+  return layout;
+}
+function buildLeafDependencies(leaf, range, finalDates, taskById, state, ctx, space) {
+  const deps = leaf.task.dependencies;
+  if (!deps || deps.length === 0) return null;
+  let changed = false;
+  const nextDeps = deps.map((dep, depIndex) => {
+    const key = `${leaf.id}#${depIndex}`;
+    const solvedLag = state.lags.get(key);
+    if (solvedLag !== void 0 && solvedLag !== dependencyLag(dep)) {
+      changed = true;
+      return { ...dep, lag: solvedLag };
+    }
+    const predTask = taskById.get(dep.taskId);
+    if (!predTask) return { ...dep, lag: dependencyLag(dep) };
+    if (ctx.subtreeIds.has(predTask.id)) {
+      return { ...dep, lag: dependencyLag(dep) };
+    }
+    const predRange = finalDates.get(predTask.id);
+    const { predStart, predEnd } = normalizePredecessorDates(
+      {
+        startDate: predRange ? predRange.start : parseDateOnly(predTask.startDate),
+        endDate: predRange ? predRange.end : parseDateOnly(predTask.endDate),
+        type: predTask.type
+      },
+      parseDateOnly
+    );
+    const lag = computeLagFromDates(
+      dep.type,
+      predStart,
+      predEnd,
+      range.start,
+      range.end,
+      ctx.businessDays,
+      ctx.weekendPredicate,
+      leaf.isMilestone ? "milestone" : void 0
+    );
+    if (lag !== dependencyLag(dep)) changed = true;
+    return { ...dep, lag };
+  });
+  void space;
+  return changed ? nextDeps : null;
+}
+function buildFinalTasks(ctx, state, layout, space) {
+  const taskById = new Map(ctx.snapshot.map((task) => [task.id, task]));
+  const finalTasks = /* @__PURE__ */ new Map();
+  for (const leaf of ctx.leaves) {
+    if (leaf.immutable) continue;
+    const range = layout.dates.get(leaf.id);
+    if (!range) continue;
+    const newStart = toIsoDate2(range.start);
+    const newEnd = toIsoDate2(range.end);
+    const startChanged = newStart !== isoOfTaskDate(leaf.task.startDate);
+    const endChanged = newEnd !== isoOfTaskDate(leaf.task.endDate);
+    const nextDeps = buildLeafDependencies(leaf, range, layout.dates, taskById, state, ctx, space);
+    if (!startChanged && !endChanged && !nextDeps) continue;
+    finalTasks.set(leaf.id, {
+      ...leaf.task,
+      startDate: newStart,
+      endDate: newEnd,
+      ...nextDeps ? { dependencies: nextDeps } : {}
+    });
+  }
+  for (const { task } of ctx.nestedParents) {
+    const children = ctx.childrenByParentId.get(task.id) ?? [];
+    let minStart = null;
+    let maxEnd = null;
+    for (const child of children) {
+      const childFinal = finalTasks.get(child.id);
+      const start = parseDateOnly(childFinal ? childFinal.startDate : child.startDate);
+      const end = parseDateOnly(childFinal ? childFinal.endDate : child.endDate);
+      if (!minStart || start.getTime() < minStart.getTime()) minStart = start;
+      if (!maxEnd || end.getTime() > maxEnd.getTime()) maxEnd = end;
+    }
+    if (!minStart || !maxEnd) continue;
+    const newStart = toIsoDate2(minStart);
+    const newEnd = toIsoDate2(maxEnd);
+    if (newStart === isoOfTaskDate(task.startDate) && newEnd === isoOfTaskDate(task.endDate)) {
+      continue;
+    }
+    finalTasks.set(task.id, { ...task, startDate: newStart, endDate: newEnd });
+  }
+  const parentChildren = ctx.childrenByParentId.get(ctx.parentTask.id) ?? [];
+  let parentStart = null;
+  let parentEnd = null;
+  for (const child of parentChildren) {
+    const childFinal = finalTasks.get(child.id);
+    const start = parseDateOnly(childFinal ? childFinal.startDate : child.startDate);
+    const end = parseDateOnly(childFinal ? childFinal.endDate : child.endDate);
+    if (!parentStart || start.getTime() < parentStart.getTime()) parentStart = start;
+    if (!parentEnd || end.getTime() > parentEnd.getTime()) parentEnd = end;
+  }
+  if (parentStart && parentEnd) {
+    const newStart = toIsoDate2(parentStart);
+    const newEnd = toIsoDate2(parentEnd);
+    if (newStart !== isoOfTaskDate(ctx.parentTask.startDate) || newEnd !== isoOfTaskDate(ctx.parentTask.endDate)) {
+      finalTasks.set(ctx.parentTask.id, {
+        ...ctx.parentTask,
+        startDate: newStart,
+        endDate: newEnd
+      });
+    }
+  }
+  return finalTasks;
+}
+function findOutgoingViolations(ctx, finalTasks) {
+  const violations = [];
+  const originalById = new Map(ctx.snapshot.map((task) => [task.id, task]));
+  for (const ref of ctx.outgoingRefs) {
+    const fromTask = finalTasks.get(ref.fromId) ?? originalById.get(ref.fromId);
+    if (!fromTask) continue;
+    const { predStart, predEnd } = normalizePredecessorDates(fromTask, parseDateOnly);
+    const required = calculateSuccessorDate(
+      predStart,
+      predEnd,
+      ref.type,
+      ref.lag,
+      ctx.businessDays,
+      ctx.weekendPredicate,
+      ref.succTask.type === "milestone" ? "milestone" : void 0
+    );
+    const succStart = parseDateOnly(ref.succTask.startDate);
+    const succEnd = ref.succTask.type === "milestone" ? succStart : parseDateOnly(ref.succTask.endDate);
+    if (ref.type === "FS" || ref.type === "SS") {
+      if (succStart.getTime() < required.getTime()) {
+        violations.push(`${ref.type} ${ref.fromId} -> ${ref.succTask.id}`);
+      }
+    } else if (succEnd.getTime() < required.getTime()) {
+      violations.push(`${ref.type} ${ref.fromId} -> ${ref.succTask.id}`);
+    }
+  }
+  return violations;
+}
+function cascadeExternalSuccessors(ctx, finalTasks) {
+  const immutableExternal = /* @__PURE__ */ new Set();
+  const seeds = [];
+  for (const ref of ctx.outgoingRefs) {
+    if (ctx.isImmutable(ref.succTask) || ref.succTask.locked === true) {
+      immutableExternal.add(ref.succTask.id);
+    }
+    if (finalTasks.has(ref.fromId) && !seeds.includes(ref.fromId)) {
+      seeds.push(ref.fromId);
+    }
+  }
+  if (immutableExternal.size > 0) {
+    return {
+      ok: false,
+      details: [`immutable external successor(s): ${[...immutableExternal].slice(0, 5).join(", ")}`]
+    };
+  }
+  if (seeds.length === 0) return { ok: true, changedExternal: [] };
+  const working = ctx.snapshot.map((task) => {
+    const final = finalTasks.get(task.id);
+    return final ?? { ...task };
+  });
+  const externalChanged = /* @__PURE__ */ new Map();
+  for (const seedId of seeds) {
+    const seedTask = working.find((task) => task.id === seedId);
+    if (!seedTask) continue;
+    const cascade = universalCascade(
+      seedTask,
+      parseDateOnly(seedTask.startDate),
+      parseDateOnly(seedTask.endDate),
+      working,
+      ctx.businessDays,
+      ctx.weekendPredicate
+    );
+    for (const updated of cascade) {
+      if (ctx.subtreeIds.has(updated.id) || updated.id === ctx.parentTask.id) continue;
+      const beforeIndex = working.findIndex((task) => task.id === updated.id);
+      if (beforeIndex < 0) continue;
+      const before = working[beforeIndex];
+      if (JSON.stringify(before) !== JSON.stringify(updated)) {
+        externalChanged.set(updated.id, updated);
+      }
+      working.splice(beforeIndex, 1, updated);
+    }
+  }
+  const changedSet = new Set(externalChanged.keys());
+  const indegree = new Map([...changedSet].map((id) => [id, 0]));
+  for (const task of externalChanged.values()) {
+    for (const dep of task.dependencies ?? []) {
+      if (changedSet.has(dep.taskId)) {
+        indegree.set(task.id, (indegree.get(task.id) ?? 0) + 1);
+      }
+    }
+  }
+  const snapshotIndexById = new Map(ctx.snapshot.map((task, index) => [task.id, index]));
+  const ready = [...changedSet].filter((id) => (indegree.get(id) ?? 0) === 0).sort((left, right) => (snapshotIndexById.get(left) ?? 0) - (snapshotIndexById.get(right) ?? 0));
+  const ordered = [];
+  const emitted = /* @__PURE__ */ new Set();
+  while (ready.length > 0) {
+    const currentId = ready.shift();
+    const current = externalChanged.get(currentId);
+    ordered.push(current);
+    emitted.add(currentId);
+    for (const [otherId, other] of externalChanged) {
+      if (emitted.has(otherId)) continue;
+      if (!(other.dependencies ?? []).some((dep) => dep.taskId === currentId)) continue;
+      const next = (indegree.get(otherId) ?? 0) - 1;
+      indegree.set(otherId, next);
+      if (next === 0) {
+        ready.push(otherId);
+        ready.sort((left, right) => (snapshotIndexById.get(left) ?? 0) - (snapshotIndexById.get(right) ?? 0));
+      }
+    }
+  }
+  for (const id of changedSet) {
+    if (!emitted.has(id)) ordered.push(externalChanged.get(id));
+  }
+  return { ok: true, changedExternal: ordered };
+}
+function validateFinalGraph(ctx, finalTasks, external) {
+  if (finalTasks.size === 0 && external.length === 0) return [];
+  const updates = /* @__PURE__ */ new Map();
+  for (const task of finalTasks.values()) updates.set(task.id, task);
+  for (const task of external) updates.set(task.id, task);
+  const finalSnapshot = ctx.snapshot.map((task) => updates.get(task.id) ?? task);
+  const validation = validateDependencies(finalSnapshot);
+  return validation.isValid ? [] : validation.errors.slice(0, 5).map((error) => `${error.type}: ${error.taskId}`);
+}
+function scaleTaskSubtreeDuration(parentId, targetDuration, snapshot, options) {
+  const resolvedOptions = options ?? {};
+  const businessDays = resolvedOptions.businessDays ?? false;
+  const validation = validateScaleInput(
+    parentId,
+    targetDuration,
+    snapshot,
+    businessDays,
+    resolvedOptions.weekendPredicate
+  );
+  if (!validation.ok) {
+    return scaleFailure(validation.code, validation.details);
+  }
+  const built = buildScaleContext(validation.parentTask, snapshot, resolvedOptions);
+  if (!built.ok) {
+    return scaleFailure(built.code, built.details);
+  }
+  const { context: ctx, space } = built;
+  const solved = solveScale(ctx, space, targetDuration);
+  const finalTasks = buildFinalTasks(ctx, solved.state, solved.layout, space);
+  const externalPolicy = resolvedOptions.externalDependencyPolicy ?? "subtree-only";
+  let externalChanged = [];
+  if (externalPolicy === "subtree-only") {
+    const violations = findOutgoingViolations(ctx, finalTasks);
+    if (violations.length > 0) {
+      return scaleFailure("EXTERNAL_DEPENDENCY_CONFLICT", violations);
+    }
+  } else {
+    const cascaded = cascadeExternalSuccessors(ctx, finalTasks);
+    if (!cascaded.ok) {
+      return scaleFailure("EXTERNAL_DEPENDENCY_CONFLICT", cascaded.details);
+    }
+    externalChanged = cascaded.changedExternal;
+  }
+  const finalErrors = validateFinalGraph(ctx, finalTasks, externalChanged);
+  if (finalErrors.length > 0) {
+    return scaleFailure("INVALID_DEPENDENCIES", finalErrors);
+  }
+  const changedLeaves = ctx.leaves.filter((leaf) => finalTasks.has(leaf.id)).map((leaf) => finalTasks.get(leaf.id));
+  const changedParents = [...ctx.nestedParents.map(({ task }) => task), ctx.parentTask].filter((task) => finalTasks.has(task.id)).map((task) => finalTasks.get(task.id));
+  const changedTasks = [...changedLeaves, ...changedParents, ...externalChanged];
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueChanged = changedTasks.filter((task) => {
+    if (seen.has(task.id)) return false;
+    seen.add(task.id);
+    return true;
+  });
+  const warnings = solved.clamped ? [
+    {
+      code: "TARGET_CLAMPED_TO_MINIMUM",
+      requestedDuration: targetDuration,
+      minimumDuration: solved.appliedSpan
+    }
+  ] : [];
+  return {
+    ok: true,
+    changedTasks: uniqueChanged,
+    changedIds: uniqueChanged.map((task) => task.id),
+    requestedDuration: targetDuration,
+    appliedDuration: solved.appliedSpan,
+    clamped: solved.clamped,
+    warnings
+  };
+}
 export {
   DAY_MS,
   addBusinessDays,
@@ -1401,6 +2522,7 @@ export {
   reflowTasksOnModeSwitch,
   removeDependenciesBetweenTasks,
   resizeTaskWithCascade,
+  scaleTaskSubtreeDuration,
   shiftBusinessDayOffset,
   subtractBusinessDays,
   universalCascade,