@davmash/bygone 0.8.12 → 0.8.14

package/out/standalone-main.js

@@ -3158,7 +3158,31 @@ var require_menuUtils = __commonJS({
         canRemovePanel: isMultiDiff && (session2?.multi?.files?.length || 0) > 1
       };
     }
-    module2.exports = { getMenuCapabilities: getMenuCapabilities2 };
+    async function collectComparisonSelection2(choosePaths, confirmSelection) {
+      const paths = [];
+      while (true) {
+        const selectedPaths = await choosePaths(paths.length);
+        if (!Array.isArray(selectedPaths) || selectedPaths.length === 0) {
+          return [];
+        }
+        for (const selectedPath of selectedPaths) {
+          if (typeof selectedPath === "string" && !paths.includes(selectedPath)) {
+            paths.push(selectedPath);
+          }
+        }
+        if (paths.length < 2) {
+          continue;
+        }
+        const decision = await confirmSelection([...paths]);
+        if (decision === "compare") {
+          return paths;
+        }
+        if (decision !== "add") {
+          return [];
+        }
+      }
+    }
+    module2.exports = { collectComparisonSelection: collectComparisonSelection2, getMenuCapabilities: getMenuCapabilities2 };
   }
 });
 
@@ -4077,16 +4101,41 @@ var require_changeTour = __commonJS({
       }
       validateMultiPanelFiles(value.files, panels.length, index);
       validateMultiPanelSteps(value.steps, panels.length, index, true);
-      if (Array.isArray(value.steps) && value.steps.length !== panels.length - 1) {
-        throw new Error(`scenes[${index}].steps must match the number of explanation stages.`);
-      }
       if (Array.isArray(value.steps)) {
+        let previousPairIndex = -1;
         value.steps.forEach((step, stepIndex) => {
-          const panel = panels[stepIndex + 1];
-          if (!isRecord2(step) || !isRecord2(panel) || panel.stageId !== step.id) {
-            throw new Error(`scenes[${index}].panels must align with explanation stage ids.`);
+          if (!isRecord2(step)) return;
+          const pairIndex = Number(step.pairIndex);
+          if (pairIndex < previousPairIndex) {
+            throw new Error(`scenes[${index}].steps must remain grouped in explanation stage order.`);
+          }
+          previousPairIndex = pairIndex;
+          if (step.stageId !== void 0) requireString(step.stageId, `scenes[${index}].steps[${stepIndex}].stageId`);
+          if (step.stageIndex !== void 0) requireNonNegativeInteger(step.stageIndex, `scenes[${index}].steps[${stepIndex}].stageIndex`);
+          if (step.focusIndex !== void 0) requireNonNegativeInteger(step.focusIndex, `scenes[${index}].steps[${stepIndex}].focusIndex`);
+          if (step.focusCount !== void 0) requirePositiveInteger(step.focusCount, `scenes[${index}].steps[${stepIndex}].focusCount`);
+          if (step.stageIndex !== void 0 && Number(step.stageIndex) !== pairIndex) {
+            throw new Error(`scenes[${index}].steps[${stepIndex}].stageIndex must match pairIndex.`);
+          }
+          if (step.focusIndex !== void 0 && step.focusCount !== void 0 && Number(step.focusIndex) >= Number(step.focusCount)) {
+            throw new Error(`scenes[${index}].steps[${stepIndex}].focusIndex must be less than focusCount.`);
           }
         });
+        for (let stageIndex = 0; stageIndex < panels.length - 1; stageIndex += 1) {
+          const panel = panels[stageIndex + 1];
+          const stageSteps = value.steps.filter((step) => isRecord2(step) && Number(step.pairIndex) === stageIndex);
+          if (!isRecord2(panel) || stageSteps.length === 0) {
+            throw new Error(`scenes[${index}].steps must cover every explanation stage.`);
+          }
+          const firstStep = stageSteps[0];
+          const fallbackStageId = isRecord2(firstStep) ? firstStep.id : void 0;
+          if (stageSteps.some((step) => {
+            if (!isRecord2(step)) return true;
+            return (step.stageId ?? fallbackStageId) !== panel.stageId;
+          })) {
+            throw new Error(`scenes[${index}].panels must align with explanation stage ids.`);
+          }
+        }
       }
     }
     function validateMultiPanelFiles(value, panelCount, index) {
@@ -4115,7 +4164,6 @@ var require_changeTour = __commonJS({
         if (deconstructed) {
           requireStringArray(step.introducedHunks, `scenes[${index}].steps[${stepIndex}].introducedHunks`);
           if (step.introducedHunks.length === 0) throw new Error(`scenes[${index}].steps[${stepIndex}].introducedHunks must be non-empty.`);
-          if (Number(step.pairIndex) !== stepIndex) throw new Error(`scenes[${index}].steps[${stepIndex}].pairIndex must match its explanation stage.`);
         }
         if (step.side !== "left" && step.side !== "right") throw new Error(`scenes[${index}].steps[${stepIndex}].side must be left or right.`);
         if (step.startLine !== void 0) requirePositiveInteger(step.startLine, `scenes[${index}].steps[${stepIndex}].startLine`);
@@ -4755,85 +4803,1282 @@ var require_changeTour = __commonJS({
       for (const { stage, claims } of stageClaims) {
         const introducedHunks = [];
         const introducedFiles = [];
+        const introducedChanges = [];
         for (const claim of claims) {
           const cumulative = cumulativeByFile.get(claim.file) || /* @__PURE__ */ new Set();
           claim.ids.forEach((id) => {
             cumulative.add(id);
             introducedHunks.push(id);
           });
-          cumulativeByFile.set(claim.file, cumulative);
-          if (!introducedFiles.includes(claim.file.path)) introducedFiles.push(claim.file.path);
+          cumulativeByFile.set(claim.file, cumulative);
+          if (!introducedFiles.includes(claim.file.path)) introducedFiles.push(claim.file.path);
+          const introducedChange = introducedChanges.find((change) => change.file === claim.file.path);
+          if (introducedChange) {
+            introducedChange.hunks.push(...claim.ids);
+          } else {
+            introducedChanges.push({ file: claim.file.path, hunks: [...claim.ids] });
+          }
+        }
+        stages.push({
+          id: stage.id,
+          title: stage.title,
+          narration: stage.narration,
+          introducedHunks,
+          introducedFiles,
+          introducedChanges,
+          cumulativeHunks: [...cumulativeByFile.values()].flatMap((ids) => [...ids]),
+          files: materializableFiles.map((file) => buildFileState(
+            file,
+            cumulativeByFile.get(file) || /* @__PURE__ */ new Set(),
+            wholeFileExclusions.has(file)
+          ))
+        });
+      }
+      for (const file of materializableFiles) {
+        const finalState = buildFileState(
+          file,
+          cumulativeByFile.get(file) || /* @__PURE__ */ new Set(),
+          wholeFileExclusions.has(file)
+        );
+        const expectedExists = file.changeKind !== "deleted";
+        if (finalState.exists !== expectedExists || finalState.content !== file.headContent) {
+          throw new Error(`Final deconstructed state does not match the target for ${file.path}.`);
+        }
+      }
+      return {
+        id: scene.id,
+        title: scene.title,
+        baseOid: inventory.range.baseOid,
+        targetOid: inventory.range.headOid,
+        baselineFiles,
+        excludedHunks: [...excludedByFile.values()].flatMap((ids) => [...ids]),
+        excludedFiles,
+        stages
+      };
+    }
+    function requireInventoryFile(inventory, path9, owner) {
+      const matches = inventory.files.filter((file) => file.path === path9 || file.previousPath === path9);
+      if (matches.length === 0) throw new Error(`${owner} references a file outside the change inventory: ${path9}`);
+      if (matches.length > 1) throw new Error(`${owner} references an ambiguous changed path: ${path9}`);
+      return matches[0];
+    }
+    function claimHunks(file, ids, owner, ownership) {
+      const known = new Set(file.units.map((unit) => unit.id));
+      for (const id of ids) {
+        if (!known.has(id)) throw new Error(`${owner} references an unknown hunk in ${file.path}: ${id}`);
+        const key = unitKey(file, id);
+        const previousOwner = ownership.get(key);
+        if (previousOwner) throw new Error(`Change unit ${id} in ${file.path} is assigned to both ${previousOwner} and ${owner}.`);
+        ownership.set(key, owner);
+      }
+    }
+    function unitKey(file, id) {
+      return `${file.previousPath || ""}\0${file.path}\0${id}`;
+    }
+    function buildFileState(file, selected, wholeFileExcluded) {
+      if (file.baseContent === void 0) throw new Error(`Missing base content for ${file.path}.`);
+      const content = materializeChangeUnits(file.baseContent, file.units, selected);
+      let exists = true;
+      if (file.changeKind === "added") exists = wholeFileExcluded || selected.size > 0;
+      if (file.changeKind === "deleted") exists = !(wholeFileExcluded || selected.size === file.units.length);
+      return {
+        path: file.path,
+        previousPath: file.previousPath,
+        changeKind: file.changeKind,
+        exists,
+        content: exists ? content : "",
+        appliedHunks: [...selected]
+      };
+    }
+    function Diff2() {
+    }
+    Diff2.prototype = {
+      diff: function diff2(oldString, newString) {
+        var _options$timeout;
+        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+        var callback = options.callback;
+        if (typeof options === "function") {
+          callback = options;
+          options = {};
+        }
+        this.options = options;
+        var self2 = this;
+        function done(value) {
+          if (callback) {
+            setTimeout(function() {
+              callback(void 0, value);
+            }, 0);
+            return true;
+          } else {
+            return value;
+          }
+        }
+        oldString = this.castInput(oldString);
+        newString = this.castInput(newString);
+        oldString = this.removeEmpty(this.tokenize(oldString));
+        newString = this.removeEmpty(this.tokenize(newString));
+        var newLen = newString.length, oldLen = oldString.length;
+        var editLength = 1;
+        var maxEditLength = newLen + oldLen;
+        if (options.maxEditLength) {
+          maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+        }
+        var maxExecutionTime = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
+        var abortAfterTimestamp = Date.now() + maxExecutionTime;
+        var bestPath = [{
+          oldPos: -1,
+          lastComponent: void 0
+        }];
+        var newPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done([{
+            value: this.join(newString),
+            count: newString.length
+          }]);
+        }
+        var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+        function execEditLength() {
+          for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+            var basePath = void 0;
+            var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+            if (removePath) {
+              bestPath[diagonalPath - 1] = void 0;
+            }
+            var canAdd = false;
+            if (addPath) {
+              var addPathNewPos = addPath.oldPos - diagonalPath;
+              canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+            }
+            var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+            if (!canAdd && !canRemove) {
+              bestPath[diagonalPath] = void 0;
+              continue;
+            }
+            if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) {
+              basePath = self2.addToPath(addPath, true, void 0, 0);
+            } else {
+              basePath = self2.addToPath(removePath, void 0, true, 1);
+            }
+            newPos = self2.extractCommon(basePath, newString, oldString, diagonalPath);
+            if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+              return done(buildValues2(self2, basePath.lastComponent, newString, oldString, self2.useLongestToken));
+            } else {
+              bestPath[diagonalPath] = basePath;
+              if (basePath.oldPos + 1 >= oldLen) {
+                maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+              }
+              if (newPos + 1 >= newLen) {
+                minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+              }
+            }
+          }
+          editLength++;
+        }
+        if (callback) {
+          (function exec() {
+            setTimeout(function() {
+              if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+                return callback();
+              }
+              if (!execEditLength()) {
+                exec();
+              }
+            }, 0);
+          })();
+        } else {
+          while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+            var ret = execEditLength();
+            if (ret) {
+              return ret;
+            }
+          }
+        }
+      },
+      addToPath: function addToPath2(path9, added, removed, oldPosInc) {
+        var last = path9.lastComponent;
+        if (last && last.added === added && last.removed === removed) {
+          return {
+            oldPos: path9.oldPos + oldPosInc,
+            lastComponent: {
+              count: last.count + 1,
+              added,
+              removed,
+              previousComponent: last.previousComponent
+            }
+          };
+        } else {
+          return {
+            oldPos: path9.oldPos + oldPosInc,
+            lastComponent: {
+              count: 1,
+              added,
+              removed,
+              previousComponent: last
+            }
+          };
+        }
+      },
+      extractCommon: function extractCommon2(basePath, newString, oldString, diagonalPath) {
+        var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+          newPos++;
+          oldPos++;
+          commonCount++;
+        }
+        if (commonCount) {
+          basePath.lastComponent = {
+            count: commonCount,
+            previousComponent: basePath.lastComponent
+          };
+        }
+        basePath.oldPos = oldPos;
+        return newPos;
+      },
+      equals: function equals2(left, right) {
+        if (this.options.comparator) {
+          return this.options.comparator(left, right);
+        } else {
+          return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+        }
+      },
+      removeEmpty: function removeEmpty2(array) {
+        var ret = [];
+        for (var i = 0; i < array.length; i++) {
+          if (array[i]) {
+            ret.push(array[i]);
+          }
+        }
+        return ret;
+      },
+      castInput: function castInput2(value) {
+        return value;
+      },
+      tokenize: function tokenize2(value) {
+        return value.split("");
+      },
+      join: function join4(chars) {
+        return chars.join("");
+      }
+    };
+    function buildValues2(diff2, lastComponent, newString, oldString, useLongestToken) {
+      var components = [];
+      var nextComponent;
+      while (lastComponent) {
+        components.push(lastComponent);
+        nextComponent = lastComponent.previousComponent;
+        delete lastComponent.previousComponent;
+        lastComponent = nextComponent;
+      }
+      components.reverse();
+      var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
+      for (; componentPos < componentLen; componentPos++) {
+        var component = components[componentPos];
+        if (!component.removed) {
+          if (!component.added && useLongestToken) {
+            var value = newString.slice(newPos, newPos + component.count);
+            value = value.map(function(value2, i) {
+              var oldValue = oldString[oldPos + i];
+              return oldValue.length > value2.length ? oldValue : value2;
+            });
+            component.value = diff2.join(value);
+          } else {
+            component.value = diff2.join(newString.slice(newPos, newPos + component.count));
+          }
+          newPos += component.count;
+          if (!component.added) {
+            oldPos += component.count;
+          }
+        } else {
+          component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count));
+          oldPos += component.count;
+          if (componentPos && components[componentPos - 1].added) {
+            var tmp = components[componentPos - 1];
+            components[componentPos - 1] = components[componentPos];
+            components[componentPos] = tmp;
+          }
+        }
+      }
+      var finalComponent = components[componentLen - 1];
+      if (componentLen > 1 && typeof finalComponent.value === "string" && (finalComponent.added || finalComponent.removed) && diff2.equals("", finalComponent.value)) {
+        components[componentLen - 2].value += finalComponent.value;
+        components.pop();
+      }
+      return components;
+    }
+    var characterDiff2 = new Diff2();
+    function diffChars2(oldStr, newStr, options) {
+      return characterDiff2.diff(oldStr, newStr, options);
+    }
+    var extendedWordChars2 = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
+    var reWhitespace2 = /\S/;
+    var wordDiff2 = new Diff2();
+    wordDiff2.equals = function(left, right) {
+      if (this.options.ignoreCase) {
+        left = left.toLowerCase();
+        right = right.toLowerCase();
+      }
+      return left === right || this.options.ignoreWhitespace && !reWhitespace2.test(left) && !reWhitespace2.test(right);
+    };
+    wordDiff2.tokenize = function(value) {
+      var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
+      for (var i = 0; i < tokens.length - 1; i++) {
+        if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars2.test(tokens[i]) && extendedWordChars2.test(tokens[i + 2])) {
+          tokens[i] += tokens[i + 2];
+          tokens.splice(i + 1, 2);
+          i--;
+        }
+      }
+      return tokens;
+    };
+    function diffWordsWithSpace2(oldStr, newStr, options) {
+      return wordDiff2.diff(oldStr, newStr, options);
+    }
+    var lineDiff2 = new Diff2();
+    lineDiff2.tokenize = function(value) {
+      if (this.options.stripTrailingCr) {
+        value = value.replace(/\r\n/g, "\n");
+      }
+      var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+      if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+        linesAndNewlines.pop();
+      }
+      for (var i = 0; i < linesAndNewlines.length; i++) {
+        var line = linesAndNewlines[i];
+        if (i % 2 && !this.options.newlineIsToken) {
+          retLines[retLines.length - 1] += line;
+        } else {
+          if (this.options.ignoreWhitespace) {
+            line = line.trim();
+          }
+          retLines.push(line);
+        }
+      }
+      return retLines;
+    };
+    var sentenceDiff2 = new Diff2();
+    sentenceDiff2.tokenize = function(value) {
+      return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+    };
+    var cssDiff2 = new Diff2();
+    cssDiff2.tokenize = function(value) {
+      return value.split(/([{}:;,]|\s+)/);
+    };
+    function _typeof2(obj) {
+      "@babel/helpers - typeof";
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof2 = function(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof2 = function(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof2(obj);
+    }
+    var objectPrototypeToString2 = Object.prototype.toString;
+    var jsonDiff2 = new Diff2();
+    jsonDiff2.useLongestToken = true;
+    jsonDiff2.tokenize = lineDiff2.tokenize;
+    jsonDiff2.castInput = function(value) {
+      var _this$options = this.options, undefinedReplacement = _this$options.undefinedReplacement, _this$options$stringi = _this$options.stringifyReplacer, stringifyReplacer = _this$options$stringi === void 0 ? function(k, v) {
+        return typeof v === "undefined" ? undefinedReplacement : v;
+      } : _this$options$stringi;
+      return typeof value === "string" ? value : JSON.stringify(canonicalize2(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
+    };
+    jsonDiff2.equals = function(left, right) {
+      return Diff2.prototype.equals.call(jsonDiff2, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"));
+    };
+    function canonicalize2(obj, stack, replacementStack, replacer, key) {
+      stack = stack || [];
+      replacementStack = replacementStack || [];
+      if (replacer) {
+        obj = replacer(key, obj);
+      }
+      var i;
+      for (i = 0; i < stack.length; i += 1) {
+        if (stack[i] === obj) {
+          return replacementStack[i];
+        }
+      }
+      var canonicalizedObj;
+      if ("[object Array]" === objectPrototypeToString2.call(obj)) {
+        stack.push(obj);
+        canonicalizedObj = new Array(obj.length);
+        replacementStack.push(canonicalizedObj);
+        for (i = 0; i < obj.length; i += 1) {
+          canonicalizedObj[i] = canonicalize2(obj[i], stack, replacementStack, replacer, key);
+        }
+        stack.pop();
+        replacementStack.pop();
+        return canonicalizedObj;
+      }
+      if (obj && obj.toJSON) {
+        obj = obj.toJSON();
+      }
+      if (_typeof2(obj) === "object" && obj !== null) {
+        stack.push(obj);
+        canonicalizedObj = {};
+        replacementStack.push(canonicalizedObj);
+        var sortedKeys = [], _key;
+        for (_key in obj) {
+          if (obj.hasOwnProperty(_key)) {
+            sortedKeys.push(_key);
+          }
+        }
+        sortedKeys.sort();
+        for (i = 0; i < sortedKeys.length; i += 1) {
+          _key = sortedKeys[i];
+          canonicalizedObj[_key] = canonicalize2(obj[_key], stack, replacementStack, replacer, _key);
+        }
+        stack.pop();
+        replacementStack.pop();
+      } else {
+        canonicalizedObj = obj;
+      }
+      return canonicalizedObj;
+    }
+    var arrayDiff2 = new Diff2();
+    arrayDiff2.tokenize = function(value) {
+      return value.slice();
+    };
+    arrayDiff2.join = arrayDiff2.removeEmpty = function(value) {
+      return value;
+    };
+    function diffArrays2(oldArr, newArr, callback) {
+      return arrayDiff2.diff(oldArr, newArr, callback);
+    }
+    var DEFAULT_MAX_INLINE_HIGHLIGHT_LINE_LENGTH2 = 500;
+    var DEFAULT_DIFF_TIMEOUT_MS2 = 100;
+    var MAX_INLINE_HIGHLIGHT_LINE_LENGTH2 = readPositiveIntegerEnv4(
+      "BYGONE_MAX_INLINE_HIGHLIGHT_LINE_LENGTH",
+      DEFAULT_MAX_INLINE_HIGHLIGHT_LINE_LENGTH2
+    );
+    var DIFF_TIMEOUT_MS2 = readPositiveIntegerEnv4("BYGONE_DIFF_TIMEOUT_MS", DEFAULT_DIFF_TIMEOUT_MS2);
+    function buildTwoWayDiffModel3(leftContent, rightContent, options = {}) {
+      const leftLines = normalizeLines2(leftContent);
+      const rightLines = normalizeLines2(rightContent);
+      const changes = diffArrays2(leftLines, rightLines, {
+        timeout: options.timeoutMs ?? DIFF_TIMEOUT_MS2
+      });
+      if (!changes) {
+        return buildConservativeTwoWayDiffModel2(leftLines, rightLines);
+      }
+      const rows = [];
+      const renderedLeftLines = [];
+      const renderedRightLines = [];
+      const blocks = [];
+      let leftLineNumber = 1;
+      let rightLineNumber = 1;
+      for (let index = 0; index < changes.length; index++) {
+        const change = changes[index];
+        const removedLines = change.removed ? change.value : [];
+        const addedLines = change.added ? change.value : [];
+        if (!change.added && !change.removed) {
+          for (const line of change.value) {
+            renderedLeftLines.push(makeDiffLine2("context", line, leftLineNumber));
+            renderedRightLines.push(makeDiffLine2("context", line, rightLineNumber));
+            rows.push(makeDiffRow2(
+              makeDiffCell2("context", line, leftLineNumber++),
+              makeDiffCell2("context", line, rightLineNumber++)
+            ));
+          }
+          continue;
+        }
+        if (change.removed && index + 1 < changes.length && changes[index + 1].added) {
+          const nextChange = changes[index + 1];
+          const leftStart = renderedLeftLines.length;
+          const rightStart = renderedRightLines.length;
+          const alignedLines = alignReplacementLines2(removedLines, nextChange.value);
+          for (const { left: removedLine, right: addedLine } of alignedLines) {
+            let renderedLeftLine;
+            let renderedRightLine;
+            if (removedLine !== void 0) {
+              renderedLeftLine = makeDiffLine2("removed", removedLine, leftLineNumber);
+              renderedLeftLines.push(renderedLeftLine);
+            }
+            if (addedLine !== void 0) {
+              renderedRightLine = makeDiffLine2("added", addedLine, rightLineNumber);
+              renderedRightLines.push(renderedRightLine);
+            }
+            if (renderedLeftLine && renderedRightLine) {
+              applyInlineHighlightPair2(renderedLeftLine, renderedRightLine);
+            }
+            rows.push(makeDiffRow2(
+              removedLine === void 0 ? makePlaceholder2() : makeDiffCell2("removed", removedLine, leftLineNumber++),
+              addedLine === void 0 ? makePlaceholder2() : makeDiffCell2("added", addedLine, rightLineNumber++)
+            ));
+          }
+          blocks.push(makeDiffBlock2("replace", leftStart, renderedLeftLines.length, rightStart, renderedRightLines.length));
+          index++;
+          continue;
+        }
+        if (change.removed) {
+          const leftStart = renderedLeftLines.length;
+          const rightStart = renderedRightLines.length;
+          for (const line of removedLines) {
+            renderedLeftLines.push(makeDiffLine2("removed", line, leftLineNumber));
+            rows.push(makeDiffRow2(
+              makeDiffCell2("removed", line, leftLineNumber++),
+              makePlaceholder2()
+            ));
+          }
+          blocks.push(makeDiffBlock2("delete", leftStart, renderedLeftLines.length, rightStart, renderedRightLines.length));
+          continue;
+        }
+        if (change.added) {
+          const leftStart = renderedLeftLines.length;
+          const rightStart = renderedRightLines.length;
+          for (const line of addedLines) {
+            renderedRightLines.push(makeDiffLine2("added", line, rightLineNumber));
+            rows.push(makeDiffRow2(
+              makePlaceholder2(),
+              makeDiffCell2("added", line, rightLineNumber++)
+            ));
+          }
+          blocks.push(makeDiffBlock2("insert", leftStart, renderedLeftLines.length, rightStart, renderedRightLines.length));
+        }
+      }
+      const hasChanges = rows.some((row) => row.left.kind !== "context" || row.right.kind !== "context");
+      return {
+        rows,
+        leftLines: renderedLeftLines,
+        rightLines: renderedRightLines,
+        blocks,
+        hasChanges
+      };
+    }
+    function buildConservativeTwoWayDiffModel2(leftLines, rightLines) {
+      const renderedLeftLines = leftLines.map((line, index) => makeDiffLine2("removed", line, index + 1));
+      const renderedRightLines = rightLines.map((line, index) => makeDiffLine2("added", line, index + 1));
+      const rows = [
+        ...leftLines.map((line, index) => makeDiffRow2(
+          makeDiffCell2("removed", line, index + 1),
+          makePlaceholder2()
+        )),
+        ...rightLines.map((line, index) => makeDiffRow2(
+          makePlaceholder2(),
+          makeDiffCell2("added", line, index + 1)
+        ))
+      ];
+      let blockKind = "replace";
+      if (leftLines.length === 0) {
+        blockKind = "insert";
+      } else if (rightLines.length === 0) {
+        blockKind = "delete";
+      }
+      return {
+        rows,
+        leftLines: renderedLeftLines,
+        rightLines: renderedRightLines,
+        blocks: rows.length === 0 ? [] : [makeDiffBlock2(blockKind, 0, leftLines.length, 0, rightLines.length)],
+        hasChanges: rows.length > 0
+      };
+    }
+    function normalizeLines2(content) {
+      if (content.length === 0) {
+        return [];
+      }
+      const lines = content.replace(/\r\n/g, "\n").split("\n");
+      if (lines[lines.length - 1] === "") {
+        lines.pop();
+      }
+      return lines;
+    }
+    var MAX_ALIGNMENT_CELLS2 = 1e4;
+    var MAX_SCORING_LINE_LENGTH2 = 2e3;
+    var MINIMUM_MATCH_SCORE2 = 0.52;
+    var MINIMUM_SINGLE_PAIR_SCORE2 = 0.35;
+    var MINIMUM_CONTEXTUAL_MATCH_SCORE2 = 0.38;
+    var MINIMUM_CONTEXTUAL_RUN_SCORE2 = 0.33;
+    var HIGH_CONFIDENCE_MATCH_SCORE2 = 0.86;
+    var AMBIGUITY_MARGIN2 = 0.08;
+    var CONTEXTUAL_AMBIGUITY_MARGIN2 = 0.05;
+    var GAP_PENALTY2 = -0.12;
+    var MAX_BOUNDED_CANDIDATES2 = 5e3;
+    var MAX_LARGE_HUNK_ANCHORS2 = 2e3;
+    var MAX_RARE_TOKEN_OCCURRENCES2 = 4;
+    var MAX_CONTEXTUAL_HUNK_LINES2 = 8;
+    var MAX_CONTEXTUAL_LENGTH_DELTA2 = 4;
+    function alignReplacementLines2(leftLines, rightLines) {
+      if (leftLines.length === 0) {
+        return rightLines.map((right) => ({ right }));
+      }
+      if (rightLines.length === 0) {
+        return leftLines.map((left) => ({ left }));
+      }
+      if (leftLines.length === 1 && rightLines.length === 1) {
+        const singletonScore = scoreReplacementLinePair2(leftLines[0], rightLines[0]);
+        if ((singletonScore.eligible || singletonScore.score >= MINIMUM_SINGLE_PAIR_SCORE2) && haveCompatibleLineRoles2(leftLines[0], rightLines[0]) && isInformativeLine2(normalizeMatchingContent2(leftLines[0])) && isInformativeLine2(normalizeMatchingContent2(rightLines[0]))) {
+          return [{ left: leftLines[0], right: rightLines[0] }];
+        }
+        return [{ left: leftLines[0] }, { right: rightLines[0] }];
+      }
+      if (leftLines.length * rightLines.length > MAX_ALIGNMENT_CELLS2) {
+        return alignLargeReplacementLines2(leftLines, rightLines);
+      }
+      const pairScores = buildPairScores2(leftLines, rightLines);
+      const scores = Array.from(
+        { length: leftLines.length + 1 },
+        () => new Array(rightLines.length + 1).fill(Number.NEGATIVE_INFINITY)
+      );
+      const moves = Array.from(
+        { length: leftLines.length + 1 },
+        () => new Array(rightLines.length + 1).fill(null)
+      );
+      scores[0][0] = 0;
+      for (let leftIndex2 = 1; leftIndex2 <= leftLines.length; leftIndex2++) {
+        scores[leftIndex2][0] = scores[leftIndex2 - 1][0] + GAP_PENALTY2;
+        moves[leftIndex2][0] = "left";
+      }
+      for (let rightIndex2 = 1; rightIndex2 <= rightLines.length; rightIndex2++) {
+        scores[0][rightIndex2] = scores[0][rightIndex2 - 1] + GAP_PENALTY2;
+        moves[0][rightIndex2] = "right";
+      }
+      for (let leftIndex2 = 1; leftIndex2 <= leftLines.length; leftIndex2++) {
+        for (let rightIndex2 = 1; rightIndex2 <= rightLines.length; rightIndex2++) {
+          const pairScore = pairScores[leftIndex2 - 1][rightIndex2 - 1];
+          const candidates = [
+            { move: "left", score: scores[leftIndex2 - 1][rightIndex2] + GAP_PENALTY2 },
+            { move: "right", score: scores[leftIndex2][rightIndex2 - 1] + GAP_PENALTY2 },
+            {
+              move: "match",
+              score: pairScore === null ? Number.NEGATIVE_INFINITY : scores[leftIndex2 - 1][rightIndex2 - 1] + pairScore
+            }
+          ];
+          const best = candidates.reduce((current, candidate) => candidate.score > current.score ? candidate : current);
+          scores[leftIndex2][rightIndex2] = best.score;
+          moves[leftIndex2][rightIndex2] = best.move;
+        }
+      }
+      const aligned = [];
+      let leftIndex = leftLines.length;
+      let rightIndex = rightLines.length;
+      while (leftIndex > 0 || rightIndex > 0) {
+        const move = moves[leftIndex][rightIndex];
+        if (move === "match") {
+          aligned.push({ left: leftLines[--leftIndex], right: rightLines[--rightIndex] });
+        } else if (move === "left") {
+          aligned.push({ left: leftLines[--leftIndex] });
+        } else {
+          aligned.push({ right: rightLines[--rightIndex] });
+        }
+      }
+      return aligned.reverse();
+    }
+    function scoreReplacementLinePair2(left, right) {
+      const normalizedLeft = normalizeMatchingContent2(left);
+      const normalizedRight = normalizeMatchingContent2(right);
+      const leftInformative = isInformativeLine2(normalizedLeft);
+      const rightInformative = isInformativeLine2(normalizedRight);
+      if (!leftInformative || !rightInformative || normalizedLeft.length > MAX_SCORING_LINE_LENGTH2 || normalizedRight.length > MAX_SCORING_LINE_LENGTH2) {
+        return {
+          score: 0,
+          eligible: false,
+          characterSimilarity: 0,
+          tokenSimilarity: 0,
+          lengthSimilarity: 0
+        };
+      }
+      if (normalizedLeft === normalizedRight) {
+        return {
+          score: 1,
+          eligible: true,
+          characterSimilarity: 1,
+          tokenSimilarity: 1,
+          lengthSimilarity: 1
+        };
+      }
+      const leftTokens = tokenizeMatchingContent2(normalizedLeft);
+      const rightTokens = tokenizeMatchingContent2(normalizedRight);
+      const characterSimilarity = lineSimilarity2(normalizedLeft, normalizedRight);
+      const tokenSimilarity = multisetDiceSimilarity2(leftTokens, rightTokens);
+      const lengthSimilarity = Math.min(normalizedLeft.length, normalizedRight.length) / Math.max(normalizedLeft.length, normalizedRight.length);
+      const boundarySimilarity = tokenBoundarySimilarity2(leftTokens, rightTokens);
+      const score = characterSimilarity * 0.52 + tokenSimilarity * 0.32 + lengthSimilarity * 0.1 + boundarySimilarity * 0.06;
+      const hasContentEvidence = characterSimilarity >= 0.52 || tokenSimilarity >= 0.45 || characterSimilarity >= 0.48 && tokenSimilarity >= 0.28;
+      return {
+        score,
+        eligible: hasContentEvidence && score >= MINIMUM_MATCH_SCORE2,
+        characterSimilarity,
+        tokenSimilarity,
+        lengthSimilarity
+      };
+    }
+    function buildPairScores2(leftLines, rightLines) {
+      const scored = leftLines.map((left) => rightLines.map((right) => scoreReplacementLinePair2(left, right)));
+      const structuralPairs = collectUniqueStructuralPairs2(leftLines, rightLines);
+      const leftRankings = scored.map((row) => rankEligibleScores2(row));
+      const rightRankings = rightLines.map((_right, rightIndex) => rankEligibleScores2(scored.map((row) => row[rightIndex])));
+      const accepted = scored.map((row, leftIndex) => row.map((candidate, rightIndex) => {
+        if (structuralPairs.has(`${leftIndex}:${rightIndex}`)) {
+          return Math.max(candidate.score, 1);
+        }
+        if (!candidate.eligible) {
+          return null;
+        }
+        const leftRanking = leftRankings[leftIndex];
+        const rightRanking = rightRankings[rightIndex];
+        const isBestOnBothSides = candidate.score === leftRanking.best && candidate.score === rightRanking.best;
+        const requiredMargin = candidate.score >= HIGH_CONFIDENCE_MATCH_SCORE2 ? AMBIGUITY_MARGIN2 / 2 : AMBIGUITY_MARGIN2;
+        const hasLeftMargin = leftRanking.best - leftRanking.second >= requiredMargin;
+        const hasRightMargin = rightRanking.best - rightRanking.second >= requiredMargin;
+        return isBestOnBothSides && hasLeftMargin && hasRightMargin ? candidate.score : null;
+      }));
+      if (Math.max(leftLines.length, rightLines.length) > MAX_CONTEXTUAL_HUNK_LINES2 || Math.abs(leftLines.length - rightLines.length) > MAX_CONTEXTUAL_LENGTH_DELTA2) {
+        return accepted;
+      }
+      const isContextualCandidate = (candidate, leftIndex, rightIndex) => candidate.score >= MINIMUM_CONTEXTUAL_MATCH_SCORE2 && haveCompatibleLineRoles2(leftLines[leftIndex], rightLines[rightIndex]) && Math.abs(leftIndex - rightIndex) <= MAX_CONTEXTUAL_LENGTH_DELTA2;
+      const leftContextRankings = scored.map((row, leftIndex) => rankScores2(row, (candidate, rightIndex) => isContextualCandidate(candidate, leftIndex, rightIndex)));
+      const rightContextRankings = rightLines.map((_right, rightIndex) => rankScores2(
+        scored.map((row) => row[rightIndex]),
+        (candidate, leftIndex) => isContextualCandidate(candidate, leftIndex, rightIndex)
+      ));
+      const isWeakRunCandidate = (candidate, leftIndex, rightIndex) => candidate.score >= MINIMUM_CONTEXTUAL_RUN_SCORE2 && haveCompatibleLineRoles2(leftLines[leftIndex], rightLines[rightIndex]) && Math.abs(leftIndex - rightIndex) <= MAX_CONTEXTUAL_LENGTH_DELTA2;
+      const leftWeakRankings = scored.map((row, leftIndex) => rankScores2(row, (candidate, rightIndex) => isWeakRunCandidate(candidate, leftIndex, rightIndex)));
+      const rightWeakRankings = rightLines.map((_right, rightIndex) => rankScores2(
+        scored.map((row) => row[rightIndex]),
+        (candidate, leftIndex) => isWeakRunCandidate(candidate, leftIndex, rightIndex)
+      ));
+      const isUnambiguousContextualCandidate = (leftIndex, rightIndex) => {
+        const candidate = scored[leftIndex][rightIndex];
+        if (!isContextualCandidate(candidate, leftIndex, rightIndex)) {
+          return false;
+        }
+        const leftRanking = leftContextRankings[leftIndex];
+        const rightRanking = rightContextRankings[rightIndex];
+        return candidate.score === leftRanking.best && candidate.score === rightRanking.best && leftRanking.best - leftRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN2 && rightRanking.best - rightRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN2;
+      };
+      const isUnambiguousWeakRunAnchor = (leftIndex, rightIndex) => {
+        const candidate = scored[leftIndex][rightIndex];
+        if (!isWeakRunCandidate(candidate, leftIndex, rightIndex)) {
+          return false;
+        }
+        const leftRanking = leftWeakRankings[leftIndex];
+        const rightRanking = rightWeakRankings[rightIndex];
+        return candidate.score === leftRanking.best && candidate.score === rightRanking.best && leftRanking.best - leftRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN2 && rightRanking.best - rightRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN2;
+      };
+      return accepted.map((row, leftIndex) => row.map((acceptedScore, rightIndex) => {
+        if (acceptedScore !== null) {
+          return acceptedScore;
+        }
+        const hasLocalSupport = isUnambiguousContextualCandidate(leftIndex, rightIndex) && (hasAcceptedDiagonalNeighbor2(accepted, leftIndex, rightIndex) || hasContextualDiagonalNeighbor2(
+          scored,
+          leftIndex,
+          rightIndex,
+          isUnambiguousContextualCandidate
+        ));
+        const hasRunSupport = hasAnchoredWeakDiagonalRun2(
+          scored,
+          leftIndex,
+          rightIndex,
+          (candidateLeftIndex, candidateRightIndex) => isWeakRunCandidate(
+            scored[candidateLeftIndex][candidateRightIndex],
+            candidateLeftIndex,
+            candidateRightIndex
+          ),
+          isUnambiguousWeakRunAnchor
+        );
+        if (!hasLocalSupport && !hasRunSupport) {
+          return null;
+        }
+        return scored[leftIndex][rightIndex].score;
+      }));
+    }
+    function hasAcceptedDiagonalNeighbor2(accepted, leftIndex, rightIndex) {
+      return leftIndex > 0 && rightIndex > 0 && accepted[leftIndex - 1][rightIndex - 1] !== null || leftIndex + 1 < accepted.length && rightIndex + 1 < accepted[leftIndex + 1].length && accepted[leftIndex + 1][rightIndex + 1] !== null;
+    }
+    function hasContextualDiagonalNeighbor2(scored, leftIndex, rightIndex, isCandidate) {
+      return leftIndex > 0 && rightIndex > 0 && isCandidate(leftIndex - 1, rightIndex - 1) || leftIndex + 1 < scored.length && rightIndex + 1 < scored[leftIndex + 1].length && isCandidate(leftIndex + 1, rightIndex + 1);
+    }
+    function hasAnchoredWeakDiagonalRun2(scored, leftIndex, rightIndex, isCandidate, isAnchor) {
+      let startLeft = leftIndex;
+      let startRight = rightIndex;
+      while (startLeft > 0 && startRight > 0 && isCandidate(startLeft - 1, startRight - 1)) {
+        startLeft--;
+        startRight--;
+      }
+      let endLeft = leftIndex;
+      let endRight = rightIndex;
+      let scoreTotal = scored[leftIndex][rightIndex].score;
+      let length = 1;
+      while (endLeft + 1 < scored.length && endRight + 1 < scored[endLeft + 1].length && isCandidate(endLeft + 1, endRight + 1)) {
+        endLeft++;
+        endRight++;
+        scoreTotal += scored[endLeft][endRight].score;
+        length++;
+      }
+      for (let scanLeft = leftIndex - 1, scanRight = rightIndex - 1; scanLeft >= startLeft && scanRight >= startRight; scanLeft--, scanRight--) {
+        scoreTotal += scored[scanLeft][scanRight].score;
+        length++;
+      }
+      return length >= 3 && scoreTotal / length >= MINIMUM_CONTEXTUAL_MATCH_SCORE2 && isAnchor(startLeft, startRight) && isAnchor(endLeft, endRight);
+    }
+    function rankScores2(scores, include) {
+      let best = Number.NEGATIVE_INFINITY;
+      let second = Number.NEGATIVE_INFINITY;
+      scores.forEach((candidate, index) => {
+        if (!include(candidate, index)) {
+          return;
+        }
+        if (candidate.score > best) {
+          second = best;
+          best = candidate.score;
+        } else if (candidate.score > second) {
+          second = candidate.score;
+        }
+      });
+      return { best, second };
+    }
+    function rankEligibleScores2(scores) {
+      let best = Number.NEGATIVE_INFINITY;
+      let second = Number.NEGATIVE_INFINITY;
+      for (const candidate of scores) {
+        if (!candidate.eligible) {
+          continue;
+        }
+        if (candidate.score > best) {
+          second = best;
+          best = candidate.score;
+        } else if (candidate.score > second) {
+          second = candidate.score;
+        }
+      }
+      return { best, second };
+    }
+    function alignLargeReplacementLines2(leftLines, rightLines) {
+      const anchors = collectLargeHunkAnchors2(leftLines, rightLines);
+      const aligned = [];
+      let leftStart = 0;
+      let rightStart = 0;
+      for (const anchor of anchors) {
+        appendBoundedSegment2(
+          aligned,
+          leftLines.slice(leftStart, anchor.leftIndex),
+          rightLines.slice(rightStart, anchor.rightIndex)
+        );
+        aligned.push({ left: leftLines[anchor.leftIndex], right: rightLines[anchor.rightIndex] });
+        leftStart = anchor.leftIndex + 1;
+        rightStart = anchor.rightIndex + 1;
+      }
+      appendBoundedSegment2(aligned, leftLines.slice(leftStart), rightLines.slice(rightStart));
+      return aligned;
+    }
+    function collectLargeHunkAnchors2(leftLines, rightLines) {
+      const candidatePairs = collectRareTokenCandidatePairs2(leftLines, rightLines);
+      if (candidatePairs === null) {
+        return [];
+      }
+      const structuralPairs = collectUniqueStructuralPairs2(leftLines, rightLines);
+      const scored = candidatePairs.map(({ leftIndex, rightIndex, exact }) => ({
+        leftIndex,
+        rightIndex,
+        exact,
+        structural: structuralPairs.has(`${leftIndex}:${rightIndex}`),
+        match: scoreReplacementLinePair2(leftLines[leftIndex], rightLines[rightIndex])
+      })).filter((candidate) => candidate.exact || candidate.structural || candidate.match.eligible);
+      const leftRankings = rankAnchorCandidates2(scored, "leftIndex");
+      const rightRankings = rankAnchorCandidates2(scored, "rightIndex");
+      const confident = scored.filter((candidate) => {
+        if (candidate.exact || candidate.structural) {
+          return true;
+        }
+        const leftRanking = leftRankings.get(candidate.leftIndex);
+        const rightRanking = rightRankings.get(candidate.rightIndex);
+        if (!leftRanking || !rightRanking || candidate.match.score !== leftRanking.best || candidate.match.score !== rightRanking.best) {
+          return false;
+        }
+        const requiredMargin = candidate.match.score >= HIGH_CONFIDENCE_MATCH_SCORE2 ? AMBIGUITY_MARGIN2 / 2 : AMBIGUITY_MARGIN2;
+        return leftRanking.best - leftRanking.second >= requiredMargin && rightRanking.best - rightRanking.second >= requiredMargin;
+      });
+      const anchors = selectMaximumWeightMonotonicAnchors2(confident, rightLines.length);
+      return anchors.length <= MAX_LARGE_HUNK_ANCHORS2 ? anchors : [];
+    }
+    function collectRareTokenCandidatePairs2(leftLines, rightLines) {
+      const leftExact = buildLinePostings2(leftLines, normalizeMatchingContent2);
+      const rightExact = buildLinePostings2(rightLines, normalizeMatchingContent2);
+      const pairs = /* @__PURE__ */ new Map();
+      for (const [line, leftIndices] of leftExact) {
+        const rightIndices = rightExact.get(line);
+        if (!isInformativeLine2(line) || leftIndices.length !== 1 || (rightIndices == null ? void 0 : rightIndices.length) !== 1) {
+          continue;
+        }
+        const leftIndex = leftIndices[0];
+        const rightIndex = rightIndices[0];
+        pairs.set(`${leftIndex}:${rightIndex}`, { leftIndex, rightIndex, exact: true });
+        if (pairs.size > MAX_BOUNDED_CANDIDATES2) {
+          return null;
+        }
+      }
+      const leftTokens = buildTokenPostings2(leftLines);
+      const rightTokens = buildTokenPostings2(rightLines);
+      for (const [token, leftIndices] of leftTokens) {
+        const rightIndices = rightTokens.get(token);
+        if (!rightIndices || leftIndices.length > MAX_RARE_TOKEN_OCCURRENCES2 || rightIndices.length > MAX_RARE_TOKEN_OCCURRENCES2) {
+          continue;
+        }
+        for (const leftIndex of leftIndices) {
+          for (const rightIndex of rightIndices) {
+            const key = `${leftIndex}:${rightIndex}`;
+            if (!pairs.has(key)) {
+              pairs.set(key, { leftIndex, rightIndex, exact: false });
+              if (pairs.size > MAX_BOUNDED_CANDIDATES2) {
+                return null;
+              }
+            }
+          }
+        }
+      }
+      return [...pairs.values()];
+    }
+    function buildLinePostings2(lines, keyForLine) {
+      const postings = /* @__PURE__ */ new Map();
+      lines.forEach((line, index) => {
+        const key = keyForLine(line);
+        const indices = postings.get(key) ?? [];
+        indices.push(index);
+        postings.set(key, indices);
+      });
+      return postings;
+    }
+    function buildTokenPostings2(lines) {
+      const postings = /* @__PURE__ */ new Map();
+      lines.forEach((line, index) => {
+        const tokens = new Set(tokenizeMatchingContent2(normalizeMatchingContent2(line)).filter(isMeaningfulAnchorToken2));
+        for (const token of tokens) {
+          const indices = postings.get(token) ?? [];
+          indices.push(index);
+          postings.set(token, indices);
+        }
+      });
+      return postings;
+    }
+    function isMeaningfulAnchorToken2(token) {
+      return token.length >= 2 && /[\p{L}\p{N}_$]/u.test(token);
+    }
+    function rankAnchorCandidates2(candidates, indexKey) {
+      const grouped = /* @__PURE__ */ new Map();
+      for (const candidate of candidates) {
+        const scores = grouped.get(candidate[indexKey]) ?? [];
+        scores.push(candidate.match);
+        grouped.set(candidate[indexKey], scores);
+      }
+      return new Map([...grouped].map(([index, scores]) => [index, rankEligibleScores2(scores)]));
+    }
+    function selectMaximumWeightMonotonicAnchors2(candidates, rightLength) {
+      const ordered = [...candidates].sort((left, right) => left.leftIndex - right.leftIndex || left.rightIndex - right.rightIndex);
+      const treeScores = new Array(rightLength + 2).fill(0);
+      const treeCandidates = new Array(rightLength + 2).fill(-1);
+      const bestScores = new Array(ordered.length).fill(0);
+      const previous = new Array(ordered.length).fill(-1);
+      for (let start = 0; start < ordered.length; ) {
+        let end = start + 1;
+        while (end < ordered.length && ordered[end].leftIndex === ordered[start].leftIndex) {
+          end++;
+        }
+        for (let index = start; index < end; index++) {
+          const prior = queryAnchorTree2(treeScores, treeCandidates, ordered[index].rightIndex);
+          const anchorBonus = ordered[index].exact || ordered[index].structural ? 0.5 : 0;
+          bestScores[index] = prior.score + ordered[index].match.score + anchorBonus;
+          previous[index] = prior.candidateIndex;
+        }
+        for (let index = start; index < end; index++) {
+          updateAnchorTree2(
+            treeScores,
+            treeCandidates,
+            ordered[index].rightIndex + 1,
+            bestScores[index],
+            index
+          );
+        }
+        start = end;
+      }
+      const best = queryAnchorTree2(treeScores, treeCandidates, rightLength + 1);
+      const anchors = [];
+      for (let index = best.candidateIndex; index >= 0; index = previous[index]) {
+        anchors.push({ leftIndex: ordered[index].leftIndex, rightIndex: ordered[index].rightIndex });
+      }
+      return anchors.reverse();
+    }
+    function queryAnchorTree2(scores, candidates, position) {
+      let score = 0;
+      let candidateIndex = -1;
+      for (let index = position; index > 0; index -= index & -index) {
+        if (scores[index] > score) {
+          score = scores[index];
+          candidateIndex = candidates[index];
+        }
+      }
+      return { score, candidateIndex };
+    }
+    function updateAnchorTree2(scores, candidates, position, score, candidateIndex) {
+      for (let index = position; index < scores.length; index += index & -index) {
+        if (score > scores[index]) {
+          scores[index] = score;
+          candidates[index] = candidateIndex;
+        }
+      }
+    }
+    function appendBoundedSegment2(aligned, leftLines, rightLines) {
+      if (leftLines.length * rightLines.length <= MAX_ALIGNMENT_CELLS2) {
+        aligned.push(...alignReplacementLines2(leftLines, rightLines));
+        return;
+      }
+      aligned.push(...leftLines.map((left) => ({ left })));
+      aligned.push(...rightLines.map((right) => ({ right })));
+    }
+    function normalizeMatchingContent2(line) {
+      return line.trim().replace(/\s+/g, " ");
+    }
+    function collectUniqueStructuralPairs2(leftLines, rightLines) {
+      const leftPostings = buildStructuralPostings2(leftLines);
+      const rightPostings = buildStructuralPostings2(rightLines);
+      const pairs = /* @__PURE__ */ new Set();
+      for (const [key, leftIndices] of leftPostings) {
+        const rightIndices = rightPostings.get(key);
+        if (leftIndices.length === 1 && (rightIndices == null ? void 0 : rightIndices.length) === 1) {
+          pairs.add(`${leftIndices[0]}:${rightIndices[0]}`);
+        }
+      }
+      return pairs;
+    }
+    function buildStructuralPostings2(lines) {
+      const postings = /* @__PURE__ */ new Map();
+      lines.forEach((line, index) => {
+        const key = declarationAnchorKey2(line);
+        if (!key) {
+          return;
+        }
+        const indices = postings.get(key) ?? [];
+        indices.push(index);
+        postings.set(key, indices);
+      });
+      return postings;
+    }
+    function haveCompatibleLineRoles2(left, right) {
+      const leftKey = declarationAnchorKey2(left);
+      const rightKey = declarationAnchorKey2(right);
+      if (!leftKey || !rightKey) {
+        return leftKey === rightKey;
+      }
+      return leftKey.split(":", 1)[0] === rightKey.split(":", 1)[0];
+    }
+    function declarationAnchorKey2(line) {
+      const normalized = normalizeMatchingContent2(line);
+      const patterns = [
+        ["function", /^(?:(?:export|default)\s+)*(?:async\s+)?function\s*\*?\s*([\p{L}_$][\p{L}\p{N}_$]*)\s*\(/u],
+        ["function", /^(?:async\s+)?def\s+([\p{L}_][\p{L}\p{N}_]*)\s*\(/u],
+        ["function", /^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([\p{L}_][\p{L}\p{N}_]*)\s*(?:<[^>]*>)?\s*\(/u],
+        ["function", /^func\s+(?:\([^)]*\)\s*)?([\p{L}_][\p{L}\p{N}_]*)\s*\(/u],
+        ["class", /^(?:(?:export|default|abstract|public)\s+)*class\s+([\p{L}_$][\p{L}\p{N}_$]*)\b/u]
+      ];
+      for (const [kind, pattern] of patterns) {
+        const match = normalized.match(pattern);
+        if (match) {
+          return `${kind}:${match[1]}`;
+        }
+      }
+      return null;
+    }
+    function isInformativeLine2(line) {
+      if (line.length < 3) {
+        return false;
+      }
+      return /[\p{L}\p{N}_$]/u.test(line) && !/^[\s()[\]{};,.:+\-*/=>|&!?'"`]+$/.test(line);
+    }
+    function tokenizeMatchingContent2(line) {
+      return line.toLowerCase().match(new RegExp("[\\p{L}_$][\\p{L}\\p{N}_$]*|\\p{N}+(?:\\.\\p{N}+)?|[^\\s\\p{L}\\p{N}_$]", "gu")) ?? [];
+    }
+    function multisetDiceSimilarity2(leftTokens, rightTokens) {
+      if (leftTokens.length + rightTokens.length === 0) {
+        return 1;
+      }
+      const remaining = /* @__PURE__ */ new Map();
+      leftTokens.forEach((token) => remaining.set(token, (remaining.get(token) ?? 0) + 1));
+      let common = 0;
+      for (const token of rightTokens) {
+        const count = remaining.get(token) ?? 0;
+        if (count > 0) {
+          common++;
+          remaining.set(token, count - 1);
+        }
+      }
+      return 2 * common / (leftTokens.length + rightTokens.length);
+    }
+    function tokenBoundarySimilarity2(leftTokens, rightTokens) {
+      if (leftTokens.length === 0 || rightTokens.length === 0) {
+        return 0;
+      }
+      const sameStart = leftTokens[0] === rightTokens[0] ? 0.5 : 0;
+      const sameEnd = leftTokens[leftTokens.length - 1] === rightTokens[rightTokens.length - 1] ? 0.5 : 0;
+      return sameStart + sameEnd;
+    }
+    function lineSimilarity2(left, right) {
+      const maxLength = left.length + right.length;
+      if (maxLength === 0) {
+        return 1;
+      }
+      const commonLength = diffChars2(left, right).filter((change) => !change.added && !change.removed).reduce((total, change) => total + change.value.length, 0);
+      return 2 * commonLength / maxLength;
+    }
+    function applyInlineHighlightPair2(leftLine, rightLine) {
+      if (leftLine.content.length > MAX_INLINE_HIGHLIGHT_LINE_LENGTH2 || rightLine.content.length > MAX_INLINE_HIGHLIGHT_LINE_LENGTH2) {
+        return;
+      }
+      const { leftSegments, rightSegments, hasInlineChanges } = buildInlineSegments2(leftLine.content, rightLine.content);
+      if (hasInlineChanges) {
+        leftLine.segments = leftSegments;
+        rightLine.segments = rightSegments;
+      }
+    }
+    function buildInlineSegments2(leftContent, rightContent) {
+      const changes = diffWordsWithSpace2(leftContent, rightContent);
+      const leftSegments = [];
+      const rightSegments = [];
+      let hasInlineChanges = false;
+      for (const change of changes) {
+        const value = change.value;
+        if (!change.added && !change.removed) {
+          const contextSegment = {
+            kind: "context",
+            text: value,
+            emphasis: false
+          };
+          leftSegments.push(contextSegment);
+          rightSegments.push(contextSegment);
+          continue;
+        }
+        const emphasis = /[^\s]/.test(value);
+        hasInlineChanges = hasInlineChanges || emphasis;
+        if (change.removed) {
+          leftSegments.push({
+            kind: "removed",
+            text: value,
+            emphasis
+          });
         }
-        stages.push({
-          id: stage.id,
-          title: stage.title,
-          narration: stage.narration,
-          introducedHunks,
-          introducedFiles,
-          cumulativeHunks: [...cumulativeByFile.values()].flatMap((ids) => [...ids]),
-          files: materializableFiles.map((file) => buildFileState(
-            file,
-            cumulativeByFile.get(file) || /* @__PURE__ */ new Set(),
-            wholeFileExclusions.has(file)
-          ))
-        });
-      }
-      for (const file of materializableFiles) {
-        const finalState = buildFileState(
-          file,
-          cumulativeByFile.get(file) || /* @__PURE__ */ new Set(),
-          wholeFileExclusions.has(file)
-        );
-        const expectedExists = file.changeKind !== "deleted";
-        if (finalState.exists !== expectedExists || finalState.content !== file.headContent) {
-          throw new Error(`Final deconstructed state does not match the target for ${file.path}.`);
+        if (change.added) {
+          rightSegments.push({
+            kind: "added",
+            text: value,
+            emphasis
+          });
         }
       }
       return {
-        id: scene.id,
-        title: scene.title,
-        baseOid: inventory.range.baseOid,
-        targetOid: inventory.range.headOid,
-        baselineFiles,
-        excludedHunks: [...excludedByFile.values()].flatMap((ids) => [...ids]),
-        excludedFiles,
-        stages
+        leftSegments,
+        rightSegments,
+        hasInlineChanges
       };
     }
-    function requireInventoryFile(inventory, path9, owner) {
-      const matches = inventory.files.filter((file) => file.path === path9 || file.previousPath === path9);
-      if (matches.length === 0) throw new Error(`${owner} references a file outside the change inventory: ${path9}`);
-      if (matches.length > 1) throw new Error(`${owner} references an ambiguous changed path: ${path9}`);
-      return matches[0];
+    function makePlaceholder2() {
+      return {
+        kind: "placeholder",
+        content: "",
+        lineNumber: null
+      };
     }
-    function claimHunks(file, ids, owner, ownership) {
-      const known = new Set(file.units.map((unit) => unit.id));
-      for (const id of ids) {
-        if (!known.has(id)) throw new Error(`${owner} references an unknown hunk in ${file.path}: ${id}`);
-        const key = unitKey(file, id);
-        const previousOwner = ownership.get(key);
-        if (previousOwner) throw new Error(`Change unit ${id} in ${file.path} is assigned to both ${previousOwner} and ${owner}.`);
-        ownership.set(key, owner);
-      }
+    function makeDiffCell2(kind, content, lineNumber) {
+      return { kind, content, lineNumber };
     }
-    function unitKey(file, id) {
-      return `${file.previousPath || ""}\0${file.path}\0${id}`;
+    function makeDiffLine2(kind, content, lineNumber) {
+      return { kind, content, lineNumber };
     }
-    function buildFileState(file, selected, wholeFileExcluded) {
-      if (file.baseContent === void 0) throw new Error(`Missing base content for ${file.path}.`);
-      const content = materializeChangeUnits(file.baseContent, file.units, selected);
-      let exists = true;
-      if (file.changeKind === "added") exists = wholeFileExcluded || selected.size > 0;
-      if (file.changeKind === "deleted") exists = !(wholeFileExcluded || selected.size === file.units.length);
+    function makeDiffRow2(left, right) {
+      return { left, right };
+    }
+    function makeDiffBlock2(kind, leftStart, leftEnd, rightStart, rightEnd) {
+      return { kind, leftStart, leftEnd, rightStart, rightEnd };
+    }
+    function readPositiveIntegerEnv4(name, fallback) {
+      var _a;
+      const value = typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a[name] : void 0;
+      const parsed = Number.parseInt(value ?? "", 10);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+    }
+    var MAX_AUTOMATIC_TOUR_FOCUS_RANGES = 4;
+    var NEARBY_TOUR_FOCUS_LINE_GAP = 8;
+    var LARGE_TOUR_FOCUS_RANGE_LINES = 120;
+    var TOUR_FOCUS_BOUNDARY_SEARCH_LINES = 12;
+    function getChangeSourceRange(diffModel, blockIndex, side) {
+      var _a, _b, _c;
+      const block = diffModel == null ? void 0 : diffModel.blocks[blockIndex];
+      const lines = side === "left" ? diffModel == null ? void 0 : diffModel.leftLines : diffModel == null ? void 0 : diffModel.rightLines;
+      if (!block || !(lines == null ? void 0 : lines.length)) {
+        return void 0;
+      }
+      const start = side === "left" ? block.leftStart : block.rightStart;
+      const end = side === "left" ? block.leftEnd : block.rightEnd;
+      const changedLines = lines.slice(start, end);
+      const startLine = ((_a = changedLines[0]) == null ? void 0 : _a.lineNumber) ?? ((_b = lines[Math.min(start, lines.length - 1)]) == null ? void 0 : _b.lineNumber);
+      if (!Number.isInteger(startLine)) {
+        return void 0;
+      }
       return {
-        path: file.path,
-        previousPath: file.previousPath,
-        changeKind: file.changeKind,
-        exists,
-        content: exists ? content : "",
-        appliedHunks: [...selected]
+        startLine,
+        endLine: ((_c = changedLines.at(-1)) == null ? void 0 : _c.lineNumber) ?? startLine
       };
     }
+    function buildTourFocusRanges(diffModel, side) {
+      const ranges = diffModel.blocks.map((_, blockIndex) => getChangeSourceRange(diffModel, blockIndex, side)).filter((range) => Boolean(range));
+      if (ranges.length === 0) return [];
+      const nearby = ranges.reduce((grouped, range) => {
+        const previous = grouped.at(-1);
+        if (previous && range.startLine - previous.endLine <= NEARBY_TOUR_FOCUS_LINE_GAP) {
+          previous.endLine = Math.max(previous.endLine, range.endLine);
+        } else {
+          grouped.push({ ...range });
+        }
+        return grouped;
+      }, []);
+      const capped = capFocusRanges(nearby, MAX_AUTOMATIC_TOUR_FOCUS_RANGES);
+      if (capped.length !== 1) return capped;
+      const [only] = capped;
+      const lineCount = only.endLine - only.startLine + 1;
+      if (lineCount < LARGE_TOUR_FOCUS_RANGE_LINES) return capped;
+      const lines = side === "left" ? diffModel.leftLines : diffModel.rightLines;
+      const partCount = Math.min(
+        MAX_AUTOMATIC_TOUR_FOCUS_RANGES,
+        Math.ceil(lineCount / LARGE_TOUR_FOCUS_RANGE_LINES)
+      );
+      const boundaries = [];
+      for (let partIndex = 1; partIndex < partCount; partIndex += 1) {
+        const target = only.startLine + Math.round(lineCount * partIndex / partCount) - 1;
+        boundaries.push(findBlankLineBoundary(lines, target, only.startLine, only.endLine));
+      }
+      const uniqueBoundaries = [...new Set(boundaries)].filter((line) => line >= only.startLine && line < only.endLine).sort((left, right) => left - right);
+      const split = [];
+      let startLine = only.startLine;
+      for (const endLine of uniqueBoundaries) {
+        split.push({ startLine, endLine });
+        startLine = endLine + 1;
+      }
+      split.push({ startLine, endLine: only.endLine });
+      return split;
+    }
+    function capFocusRanges(ranges, maximum) {
+      if (ranges.length <= maximum) return ranges.map((range) => ({ ...range }));
+      const capped = [];
+      for (let index = 0; index < maximum; index += 1) {
+        const startIndex = Math.floor(index * ranges.length / maximum);
+        const endIndex = Math.floor((index + 1) * ranges.length / maximum) - 1;
+        capped.push({
+          startLine: ranges[startIndex].startLine,
+          endLine: ranges[endIndex].endLine
+        });
+      }
+      return capped;
+    }
+    function findBlankLineBoundary(lines, target, minimum, maximum) {
+      for (let distance = 0; distance <= TOUR_FOCUS_BOUNDARY_SEARCH_LINES; distance += 1) {
+        for (const candidate of distance === 0 ? [target] : [target + distance, target - distance]) {
+          if (candidate < minimum || candidate >= maximum) continue;
+          const line = lines.find((entry) => entry.lineNumber === candidate);
+          if ((line == null ? void 0 : line.content.trim()) === "") return candidate;
+        }
+      }
+      return Math.min(Math.max(target, minimum), maximum - 1);
+    }
     var import_child_process32 = require("child_process");
     var CHANGE_TOUR_CONTEXT_VERSION = 1;
     var DEFAULT_MAX_PATCH_BYTES = 128 * 1024;
@@ -5162,7 +6407,8 @@ var require_changeTour = __commonJS({
               repoRoot,
               authoredScene,
               authoredScene.base || ((_a = source.range) == null ? void 0 : _a.base),
-              authoredScene.target || ((_b = source.range) == null ? void 0 : _b.head)
+              authoredScene.target || ((_b = source.range) == null ? void 0 : _b.head),
+              [...available.keys()]
             );
             scenes.push(deconstructedScene);
             sceneIds.push(deconstructedScene.id);
@@ -5208,7 +6454,7 @@ var require_changeTour = __commonJS({
       }
       return { scenes, chapters };
     }
-    function buildDeconstructedManifestScene(repoRoot, source, baseRef, targetRef) {
+    function buildDeconstructedManifestScene(repoRoot, source, baseRef, targetRef, availableFilePaths = []) {
       const compiled = buildDeconstructedScene(repoRoot, source, { baseRef, headRef: targetRef });
       const panels = [{
         id: "explanation-baseline",
@@ -5220,9 +6466,15 @@ var require_changeTour = __commonJS({
         role: "stage",
         stageId: stage.id
       }))];
-      const includedPaths = [...new Set(compiled.stages.flatMap((stage) => stage.introducedFiles))];
+      const materializablePaths = new Set(compiled.baselineFiles.map((file) => file.path));
+      const includedPaths = availableFilePaths.length > 0 ? availableFilePaths.filter((filePath) => materializablePaths.has(filePath)).sort() : [...materializablePaths].sort();
+      const missingIntroducedPath = compiled.stages.flatMap((stage) => stage.introducedFiles).find((filePath) => !includedPaths.includes(filePath));
+      if (missingIntroducedPath) {
+        throw new Error(`Deconstructed tour file is not renderable: ${missingIntroducedPath}`);
+      }
+      const introducedPaths = new Set(compiled.stages.flatMap((stage) => stage.introducedFiles));
       let totalContentBytes = 0;
-      const files = includedPaths.map((filePath) => {
+      const files = includedPaths.flatMap((filePath) => {
         const states = [
           compiled.baselineFiles.find((file) => file.path === filePath),
           ...compiled.stages.map((stage) => stage.files.find((file) => file.path === filePath))
@@ -5230,18 +6482,23 @@ var require_changeTour = __commonJS({
         if (states.some((state) => !state)) {
           throw new Error(`Deconstructed scene ${source.id} is missing virtual state for ${filePath}.`);
         }
-        return {
+        const fileContentBytes = states.reduce((total, state) => total + Buffer.byteLength((state == null ? void 0 : state.content) || "", "utf8"), 0);
+        const exceedsFileLimit = states.some((state) => {
+          const content = Buffer.from((state == null ? void 0 : state.content) || "", "utf8");
+          return content.length > DEFAULT_MAX_TOUR_FILE_BYTES || hasLineLongerThan(content, DEFAULT_MAX_TOUR_LINE_BYTES);
+        });
+        const exceedsSceneLimit = totalContentBytes + fileContentBytes > DEFAULT_MAX_STACK_CONTENT_BYTES;
+        if (exceedsFileLimit || exceedsSceneLimit) {
+          if (introducedPaths.has(filePath)) {
+            throw new Error(exceedsFileLimit ? `Deconstructed tour file is too large to present: ${filePath}` : `Deconstructed tour content exceeds ${DEFAULT_MAX_STACK_CONTENT_BYTES} bytes.`);
+          }
+          return [];
+        }
+        totalContentBytes += fileContentBytes;
+        return [{
           path: filePath,
           panels: states.map((state, index) => {
             if (!state) throw new Error(`Missing virtual state for ${filePath}.`);
-            const content = Buffer.from(state.content, "utf8");
-            if (content.length > DEFAULT_MAX_TOUR_FILE_BYTES || hasLineLongerThan(content, DEFAULT_MAX_TOUR_LINE_BYTES)) {
-              throw new Error(`Deconstructed tour file is too large to present: ${filePath}`);
-            }
-            totalContentBytes += content.length;
-            if (totalContentBytes > DEFAULT_MAX_STACK_CONTENT_BYTES) {
-              throw new Error(`Deconstructed tour content exceeds ${DEFAULT_MAX_STACK_CONTENT_BYTES} bytes.`);
-            }
             return {
               id: panels[index].id,
               label: `${panels[index].label} / ${filePath}${state.exists ? "" : " (absent)"}`,
@@ -5250,9 +6507,10 @@ var require_changeTour = __commonJS({
               exists: state.exists
             };
           })
-        };
+        }];
       });
       if (files.length === 0) throw new Error(`Deconstructed scene ${source.id} has no staged files.`);
+      const steps = buildDeconstructedFocusSteps(source.id, compiled.stages, files);
       return {
         id: source.id,
         kind: "deconstructed-diff",
@@ -5270,17 +6528,63 @@ var require_changeTour = __commonJS({
         },
         panels,
         files,
-        steps: compiled.stages.map((stage, index) => ({
-          id: stage.id,
-          title: stage.title,
-          body: stage.narration,
-          file: stage.introducedFiles[0],
-          pairIndex: index,
-          side: "right",
-          introducedHunks: stage.introducedHunks
-        }))
+        steps
       };
     }
+    function buildDeconstructedFocusSteps(sceneId, stages, files) {
+      const reservedIds = new Set(stages.map((stage) => stage.id));
+      const usedIds = /* @__PURE__ */ new Set();
+      return stages.flatMap((stage, stageIndex) => {
+        const focuses = stage.introducedChanges.flatMap((change) => {
+          const file = files.find((candidate) => candidate.path === change.file);
+          const left = file == null ? void 0 : file.panels[stageIndex];
+          const right = file == null ? void 0 : file.panels[stageIndex + 1];
+          if (!file || !left || !right) {
+            throw new Error(`Deconstructed scene ${sceneId} is missing comparison state for ${change.file}.`);
+          }
+          const diffModel = buildTwoWayDiffModel3(left.content, right.content);
+          const side = left.exists && !right.exists ? "left" : "right";
+          const ranges = buildTourFocusRanges(diffModel, side);
+          if (ranges.length === 0) {
+            throw new Error(`Deconstructed stage ${stage.id} has no visible change for ${change.file}.`);
+          }
+          return ranges.map((range) => ({
+            file: change.file,
+            hunks: change.hunks,
+            side,
+            ...range
+          }));
+        });
+        return focuses.map((focus, focusIndex) => ({
+          id: focusIndex === 0 ? claimDeconstructedStageId(stage.id, usedIds) : claimDeconstructedFocusId(`${stage.id}-focus-${focusIndex + 1}`, reservedIds, usedIds),
+          title: focuses.length === 1 ? stage.title : `${stage.title} \xB7 ${focus.file} \xB7 Focus ${focusIndex + 1}/${focuses.length}`,
+          body: stage.narration,
+          file: focus.file,
+          pairIndex: stageIndex,
+          side: focus.side,
+          startLine: focus.startLine,
+          endLine: focus.endLine,
+          introducedHunks: [...focus.hunks],
+          stageId: stage.id,
+          stageIndex,
+          focusIndex,
+          focusCount: focuses.length
+        }));
+      });
+    }
+    function claimDeconstructedStageId(stageId, usedIds) {
+      usedIds.add(stageId);
+      return stageId;
+    }
+    function claimDeconstructedFocusId(preferredId, reservedIds, usedIds) {
+      let candidate = preferredId;
+      let suffix = 2;
+      while (usedIds.has(candidate) || reservedIds.has(candidate)) {
+        candidate = `${preferredId}-${suffix++}`;
+      }
+      usedIds.add(candidate);
+      return candidate;
+    }
     function buildStackedScene(repoRoot, source, availableFilePaths) {
       const stack = source.stack.map((entry) => ({
         id: entry.id,
@@ -9297,7 +10601,7 @@ var require_package = __commonJS({
       displayName: "Bygone",
       desktopName: "com.davidmashburn.bygone.desktop",
       description: "See how change happened. Visual diff and file history for VS Code.",
-      version: "0.8.12",
+      version: "0.8.14",
       author: "David Mashburn",
       license: "MIT",
       private: false,
@@ -22531,7 +23835,7 @@ var { searchFileHistory: searchFileHistory2 } = (init_gitHistorySearch(), __toCo
 var { classifyAuthoredTourPaths: classifyAuthoredTourPaths2, discoverAuthoredTourDocument: discoverAuthoredTourDocument2 } = (init_tourDocument(), __toCommonJS(tourDocument_exports));
 var { materializeBranchReviewTrees: materializeBranchReviewTrees2, materializeGitTree: materializeGitTree2, resolveBranchReviewRange: resolveBranchReviewRange2, resolveReviewPathPair: resolveReviewPathPair2 } = (init_gitComparison(), __toCommonJS(gitComparison_exports));
 var { buildDirectoryNavigationState } = require_navigationUtils();
-var { getMenuCapabilities } = require_menuUtils();
+var { collectComparisonSelection, getMenuCapabilities } = require_menuUtils();
 var {
   cloneSessionSource,
   createBranchReviewSource,
@@ -22611,6 +23915,8 @@ var wordWrapEnabled = false;
 var wordWrapAvailable = false;
 var repositorySearch = null;
 var lastRepositoryReplacement = null;
+var pendingLaunchPrompt = null;
+var nextLaunchPromptId = 1;
 var appIsQuitting = false;
 var restoringWindowState = false;
 if (!singleInstanceLock) {
@@ -23041,40 +24347,52 @@ ${HELP_URL}`,
     {
       label: "File",
       submenu: [
+        {
+          label: "New Blank Comparison",
+          accelerator: "CmdOrCtrl+N",
+          click: () => runMenuAction("open a blank comparison", openBlankDiff)
+        },
+        { type: "separator" },
         {
           label: "Compare Files\u2026",
           accelerator: "CmdOrCtrl+O",
-          click: () => {
-            void openCompareFilesDialog();
-          }
+          click: () => runMenuAction("compare files", openCompareFilesDialog)
         },
         {
           label: "Compare Directories\u2026",
           accelerator: "CmdOrCtrl+Shift+O",
-          click: () => {
-            void openCompareDirectoriesDialog();
-          }
+          click: () => runMenuAction("compare directories", openCompareDirectoriesDialog)
         },
+        { type: "separator" },
         {
-          label: "Add Panel to Left\u2026",
-          enabled: canAddPanel,
-          click: () => {
-            void addPanelFromMenu("left");
-          }
+          label: "View File or Directory History\u2026",
+          accelerator: "CmdOrCtrl+Shift+H",
+          click: () => runMenuAction("open Git history", openHistoryDialog)
         },
         {
-          label: "Add Panel to Right\u2026",
-          enabled: canAddPanel,
-          click: () => {
-            void addPanelFromMenu("right");
-          }
+          label: "Open Authored Tour\u2026",
+          click: () => runMenuAction("open an authored tour", openAuthoredTourDialog)
         },
+        { type: "separator" },
         {
-          label: "Remove Active Panel",
-          enabled: canRemovePanel,
-          click: () => {
-            void removeActivePanelFromMenu();
-          }
+          label: "Comparison Panels",
+          submenu: [
+            {
+              label: "Add Panel to Left\u2026",
+              enabled: canAddPanel,
+              click: () => runMenuAction("add a panel", () => addPanelFromMenu("left"))
+            },
+            {
+              label: "Add Panel to Right\u2026",
+              enabled: canAddPanel,
+              click: () => runMenuAction("add a panel", () => addPanelFromMenu("right"))
+            },
+            {
+              label: "Remove Active Panel",
+              enabled: canRemovePanel,
+              click: () => runMenuAction("remove the active panel", removeActivePanelFromMenu)
+            }
+          ]
         },
         { type: "separator" },
         ...fileActionItems,
@@ -23136,9 +24454,7 @@ ${HELP_URL}`,
         {
           label: "Search in Files\u2026",
           accelerator: "CmdOrCtrl+Alt+F",
-          click: () => {
-            void openRepositorySearchDialog();
-          }
+          click: () => runMenuAction("search in files", openRepositorySearchDialog)
         },
         { type: "separator" },
         {
@@ -23182,35 +24498,13 @@ ${HELP_URL}`,
       label: "Git",
       submenu: [
         {
-          label: "View File or Directory History\u2026",
-          accelerator: "CmdOrCtrl+Shift+H",
-          click: () => {
-            void openHistoryDialog();
-          }
+          label: "Compare Revisions\u2026",
+          click: () => runMenuAction("compare Git revisions", openGitRefsDialog)
         },
         {
-          label: "Explore Current Branch Change",
+          label: "Review Branch Change\u2026",
           accelerator: "CmdOrCtrl+Shift+R",
-          click: () => {
-            void openBranchReviewDialog();
-          }
-        },
-        { type: "separator" },
-        {
-          label: "Older Commit",
-          accelerator: "Alt+Left",
-          enabled: isHistory,
-          click: () => {
-            void navigateHistory("back");
-          }
-        },
-        {
-          label: "Newer Commit",
-          accelerator: "Alt+Right",
-          enabled: isHistory,
-          click: () => {
-            void navigateHistory("forward");
-          }
+          click: () => runMenuAction("review a branch change", openBranchReviewDialog)
         }
       ]
     },
@@ -23219,15 +24513,11 @@ ${HELP_URL}`,
       submenu: [
         {
           label: "Present Current Branch",
-          click: () => {
-            void presentCurrentBranch();
-          }
+          click: () => runMenuAction("present the current branch", presentCurrentBranch)
         },
         {
-          label: "Open Authored Tour\u2026",
-          click: () => {
-            void openAuthoredTourDialog().catch((error) => showError(`Could not open Bygone presentation: ${getErrorMessage(error)}`));
-          }
+          label: "Present Branch or Ref\u2026",
+          click: () => runMenuAction("present a branch or ref", openPresentBranchDialog)
         },
         { type: "separator" },
         {
@@ -23260,6 +24550,23 @@ ${HELP_URL}`,
           click: () => {
             void returnToDirectoryView();
           }
+        },
+        { type: "separator" },
+        {
+          label: "Older Commit",
+          accelerator: "Alt+Left",
+          enabled: isHistory,
+          click: () => {
+            void navigateHistory("back");
+          }
+        },
+        {
+          label: "Newer Commit",
+          accelerator: "Alt+Right",
+          enabled: isHistory,
+          click: () => {
+            void navigateHistory("forward");
+          }
         }
       ]
     },
@@ -23362,9 +24669,38 @@ ${HELP_URL}`,
   ];
   Menu.setApplicationMenu(Menu.buildFromTemplate(template));
 }
+function runMenuAction(description, action) {
+  void Promise.resolve().then(action).catch((error) => showError(`Could not ${description}: ${getErrorMessage(error)}`));
+}
 async function presentCurrentBranch() {
-  const cwd = getSourceRepoRoot(session.source) || process.cwd();
-  await openTourPresentation([], cwd);
+  const repoRoot = await resolveOrChooseGitRepository("Select a Git repository to present");
+  if (repoRoot) {
+    await openTourPresentation([], repoRoot);
+  }
+}
+async function openPresentBranchDialog() {
+  const repoRoot = await resolveOrChooseGitRepository("Select a Git repository to present");
+  if (!repoRoot) {
+    return;
+  }
+  openLaunchPrompt({
+    kind: "present-branch",
+    title: "Present Branch or Ref",
+    description: `Repository: ${repoRoot}`,
+    submitLabel: "Present",
+    fields: [
+      { name: "head", label: "Head branch or ref", value: "HEAD", required: true },
+      { name: "base", label: "Base branch or ref (optional)", value: "" }
+    ]
+  }, async (values) => {
+    const head = values.head.trim() || "HEAD";
+    const base = values.base.trim();
+    const args = [head];
+    if (base) {
+      args.push(tokensFor("base")[0], base);
+    }
+    await openTourPresentation(args, repoRoot);
+  });
 }
 async function showRepositorySearchStatus() {
   const capability = detectRipgrepCapability2();
@@ -23973,6 +25309,24 @@ async function handleRendererMessage(message) {
     await refreshSession();
     return;
   }
+  if (message.type === "submitLaunchPrompt" && Number.isInteger(message.requestId) && message.requestId === pendingLaunchPrompt?.requestId && message.values && typeof message.values === "object" && !Array.isArray(message.values)) {
+    const prompt = pendingLaunchPrompt;
+    pendingLaunchPrompt = null;
+    const values = Object.fromEntries(prompt.fieldNames.map((fieldName) => [
+      fieldName,
+      typeof message.values[fieldName] === "string" ? message.values[fieldName] : ""
+    ]));
+    try {
+      await prompt.submit(values);
+    } catch (error) {
+      await showError(`Could not ${prompt.description}: ${getErrorMessage(error)}`);
+    }
+    return;
+  }
+  if (message.type === "cancelLaunchPrompt" && Number.isInteger(message.requestId) && message.requestId === pendingLaunchPrompt?.requestId) {
+    pendingLaunchPrompt = null;
+    return;
+  }
   if (message.type === "searchChangeSet" && Number.isInteger(message.requestId)) {
     searchCurrentChangeSet(message);
     return;
@@ -24126,24 +25480,115 @@ async function handleRendererMessage(message) {
   }
 }
 async function openCompareFilesDialog() {
-  if (!mainWindow) {
+  const filePaths = await collectComparisonPaths("file");
+  if (filePaths.length < 2) {
     return;
   }
-  const result = await dialog.showOpenDialog(mainWindow, {
-    title: "Select two files to compare",
-    properties: ["openFile", "multiSelections"]
+  if (filePaths.length === 2) {
+    await openDiff(filePaths[0], filePaths[1]);
+  } else {
+    await openMultiDiff(filePaths);
+  }
+}
+async function collectComparisonPaths(kind) {
+  ensureExploreWindow();
+  const isDirectory = kind === "directory";
+  const noun = isDirectory ? "directory" : "file";
+  return collectComparisonSelection(async (selectedCount) => {
+    const result = await dialog.showOpenDialog(mainWindow, {
+      title: selectedCount === 0 ? `Select ${noun}s to compare` : `Add ${noun}${selectedCount === 1 ? "" : "s"} to the comparison`,
+      properties: [isDirectory ? "openDirectory" : "openFile", "multiSelections"]
+    });
+    if (result.canceled) {
+      return null;
+    }
+    return result.filePaths.map((selectedPath) => path8.resolve(selectedPath));
+  }, async (paths) => {
+    const choice = await dialog.showMessageBox(mainWindow, {
+      type: "question",
+      buttons: [`Compare ${paths.length}`, "Add More\u2026", "Cancel"],
+      defaultId: 0,
+      cancelId: 2,
+      message: `Compare ${paths.length} selected ${noun}${paths.length === 1 ? "" : "s"}?`,
+      detail: paths.join("\n")
+    });
+    if (choice.response === 0) {
+      return "compare";
+    }
+    return choice.response === 1 ? "add" : "cancel";
+  });
+}
+function ensureExploreWindow() {
+  ensureMainWindow();
+  if (!mainWindow.isVisible()) {
+    mainWindow.show();
+  }
+  mainWindow.focus();
+}
+function openLaunchPrompt(config, submit) {
+  ensureExploreWindow();
+  const requestId = nextLaunchPromptId++;
+  pendingLaunchPrompt = {
+    requestId,
+    fieldNames: config.fields.map((field) => field.name),
+    description: config.failureDescription || config.title.toLowerCase(),
+    submit
+  };
+  postToRenderer({
+    type: "openLaunchPrompt",
+    requestId,
+    ...config
   });
-  if (result.canceled || result.filePaths.length < 2) {
-    if (!result.canceled) {
-      await showInfo("Select at least two files to compare.");
+}
+async function resolveOrChooseGitRepository(title) {
+  const sourcePath = session.source?.repoRoot || session.source?.path || session.source?.paths?.[0];
+  const sourceCandidate = sourcePath && getPathKind(sourcePath) === "file" ? path8.dirname(sourcePath) : sourcePath;
+  const candidates = [sourceCandidate, launchArguments.cwd, process.cwd()].filter((candidate, index, all) => candidate && all.indexOf(candidate) === index);
+  for (const candidate of candidates) {
+    try {
+      return fs7.realpathSync(runGit(["rev-parse", "--show-toplevel"], candidate));
+    } catch {
     }
-    return;
   }
-  if (result.filePaths.length === 2) {
-    await openDiff(result.filePaths[0], result.filePaths[1]);
-  } else {
-    await openMultiDiff(result.filePaths);
+  ensureExploreWindow();
+  const result = await dialog.showOpenDialog(mainWindow, {
+    title,
+    properties: ["openDirectory"]
+  });
+  if (result.canceled || result.filePaths.length === 0) {
+    return null;
+  }
+  try {
+    return fs7.realpathSync(runGit(["rev-parse", "--show-toplevel"], result.filePaths[0]));
+  } catch (error) {
+    await showError(`The selected directory is not inside a Git repository: ${getErrorMessage(error)}`);
+    return null;
+  }
+}
+async function openGitRefsDialog() {
+  const repoRoot = await resolveOrChooseGitRepository("Select a Git repository to compare");
+  if (!repoRoot) {
+    return;
   }
+  openLaunchPrompt({
+    kind: "git-refs",
+    title: "Compare Git Revisions",
+    description: `Repository: ${repoRoot}`,
+    submitLabel: "Compare",
+    fields: [{
+      name: "refs",
+      label: "Revisions (two or more, separated by spaces)",
+      value: "HEAD~1 HEAD",
+      required: true
+    }]
+  }, async (values) => {
+    const refs = values.refs.trim().split(/\s+/).filter(Boolean);
+    if (refs.length < 2) {
+      await showInfo("Enter at least two Git revisions to compare.");
+      return;
+    }
+    await openGitRefs(repoRoot, refs);
+  });
 }
 async function openDroppedFiles(paths) {
   const normalizedPaths = paths.filter((candidate) => typeof candidate === "string" && candidate.length > 0).map((candidate) => path8.resolve(candidate)).filter((candidate, index, all) => all.indexOf(candidate) === index);
@@ -24208,37 +25653,29 @@ async function openHistoryDialog() {
   await openHistory(targetPath, historyIncludeStagedPreference);
 }
 async function openBranchReviewDialog() {
-  let reviewRoot = launchArguments.cwd || process.cwd();
-  try {
-    runGit(["rev-parse", "--show-toplevel"], reviewRoot);
-  } catch {
-    if (!mainWindow) {
-      return;
-    }
-    const result = await dialog.showOpenDialog(mainWindow, {
-      title: "Select a Git repository to review",
-      properties: ["openDirectory"]
-    });
-    if (result.canceled || result.filePaths.length === 0) {
-      return;
-    }
-    reviewRoot = result.filePaths[0];
-  }
-  await openGitBranchReview(reviewRoot, "HEAD");
-}
-async function openCompareDirectoriesDialog() {
-  if (!mainWindow) {
+  const repoRoot = await resolveOrChooseGitRepository("Select a Git repository to review");
+  if (!repoRoot) {
     return;
   }
-  const result = await dialog.showOpenDialog(mainWindow, {
-    title: "Select directories to compare",
-    properties: ["openDirectory", "multiSelections"]
+  openLaunchPrompt({
+    kind: "review-branch",
+    title: "Review Branch Change",
+    description: `Repository: ${repoRoot}`,
+    submitLabel: "Review",
+    fields: [
+      { name: "head", label: "Head branch or ref", value: "HEAD", required: true },
+      { name: "base", label: "Base branch or ref (optional)", value: "" }
+    ]
+  }, async (values) => {
+    await openGitBranchReview(repoRoot, values.head.trim() || "HEAD", values.base.trim() || void 0);
   });
-  if (result.canceled || result.filePaths.length < 2) {
-    if (!result.canceled) await showInfo("Select at least two directories to compare.");
+}
+async function openCompareDirectoriesDialog() {
+  const directoryPaths = await collectComparisonPaths("directory");
+  if (directoryPaths.length < 2) {
     return;
   }
-  await openDirectories(result.filePaths);
+  await openDirectories(directoryPaths);
 }
 async function openDirectories(dirs, options = {}) {
   const resolvedDirs = dirs.map((dir) => path8.resolve(dir)).filter((dir, index, all) => all.indexOf(dir) === index);