@davmash/bygone 0.8.12 → 0.8.13

package/out/tourCoverage.js

@@ -629,16 +629,41 @@ function validateDeconstructedScene(value, index) {
   }
   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 (!isRecord(step) || !isRecord(panel) || panel.stageId !== step.id) {
-        throw new Error(`scenes[${index}].panels must align with explanation stage ids.`);
+      if (!isRecord(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) => isRecord(step) && Number(step.pairIndex) === stageIndex);
+      if (!isRecord(panel) || stageSteps.length === 0) {
+        throw new Error(`scenes[${index}].steps must cover every explanation stage.`);
+      }
+      const firstStep = stageSteps[0];
+      const fallbackStageId = isRecord(firstStep) ? firstStep.id : void 0;
+      if (stageSteps.some((step) => {
+        if (!isRecord(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) {
@@ -667,7 +692,6 @@ function validateMultiPanelSteps(value, panelCount, index, deconstructed) {
     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`);
@@ -1068,6 +1092,7 @@ function compileDeconstructedScene(inventory, scene) {
   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) => {
@@ -1076,6 +1101,12 @@ function compileDeconstructedScene(inventory, scene) {
       });
       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,
@@ -1083,6 +1114,7 @@ function compileDeconstructedScene(inventory, scene) {
       narration: stage.narration,
       introducedHunks,
       introducedFiles,
+      introducedChanges,
       cumulativeHunks: [...cumulativeByFile.values()].flatMap((ids) => [...ids]),
       files: materializableFiles.map((file) => buildFileState(
         file,
@@ -1148,6 +1180,1201 @@ function buildFileState(file, selected, wholeFileExcluded) {
   };
 }
 
+// node_modules/diff/lib/index.mjs
+function Diff() {
+}
+Diff.prototype = {
+  diff: function diff(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 self = 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 = self.addToPath(addPath, true, void 0, 0);
+        } else {
+          basePath = self.addToPath(removePath, void 0, true, 1);
+        }
+        newPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(buildValues(self, basePath.lastComponent, newString, oldString, self.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 addToPath(path, added, removed, oldPosInc) {
+    var last = path.lastComponent;
+    if (last && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: {
+          count: last.count + 1,
+          added,
+          removed,
+          previousComponent: last.previousComponent
+        }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: {
+          count: 1,
+          added,
+          removed,
+          previousComponent: last
+        }
+      };
+    }
+  },
+  extractCommon: function extractCommon(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 equals(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 removeEmpty(array) {
+    var ret = [];
+    for (var i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  },
+  castInput: function castInput(value) {
+    return value;
+  },
+  tokenize: function tokenize(value) {
+    return value.split("");
+  },
+  join: function join(chars) {
+    return chars.join("");
+  }
+};
+function buildValues(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 characterDiff = new Diff();
+function diffChars(oldStr, newStr, options) {
+  return characterDiff.diff(oldStr, newStr, options);
+}
+var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
+var reWhitespace = /\S/;
+var wordDiff = new Diff();
+wordDiff.equals = function(left, right) {
+  if (this.options.ignoreCase) {
+    left = left.toLowerCase();
+    right = right.toLowerCase();
+  }
+  return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
+};
+wordDiff.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] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
+      tokens[i] += tokens[i + 2];
+      tokens.splice(i + 1, 2);
+      i--;
+    }
+  }
+  return tokens;
+};
+function diffWordsWithSpace(oldStr, newStr, options) {
+  return wordDiff.diff(oldStr, newStr, options);
+}
+var lineDiff = new Diff();
+lineDiff.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 sentenceDiff = new Diff();
+sentenceDiff.tokenize = function(value) {
+  return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+};
+var cssDiff = new Diff();
+cssDiff.tokenize = function(value) {
+  return value.split(/([{}:;,]|\s+)/);
+};
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+var objectPrototypeToString = Object.prototype.toString;
+var jsonDiff = new Diff();
+jsonDiff.useLongestToken = true;
+jsonDiff.tokenize = lineDiff.tokenize;
+jsonDiff.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(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
+};
+jsonDiff.equals = function(left, right) {
+  return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"));
+};
+function canonicalize(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]" === objectPrototypeToString.call(obj)) {
+    stack.push(obj);
+    canonicalizedObj = new Array(obj.length);
+    replacementStack.push(canonicalizedObj);
+    for (i = 0; i < obj.length; i += 1) {
+      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
+    }
+    stack.pop();
+    replacementStack.pop();
+    return canonicalizedObj;
+  }
+  if (obj && obj.toJSON) {
+    obj = obj.toJSON();
+  }
+  if (_typeof(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] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
+    }
+    stack.pop();
+    replacementStack.pop();
+  } else {
+    canonicalizedObj = obj;
+  }
+  return canonicalizedObj;
+}
+var arrayDiff = new Diff();
+arrayDiff.tokenize = function(value) {
+  return value.slice();
+};
+arrayDiff.join = arrayDiff.removeEmpty = function(value) {
+  return value;
+};
+function diffArrays(oldArr, newArr, callback) {
+  return arrayDiff.diff(oldArr, newArr, callback);
+}
+
+// src/diffEngine.ts
+var DEFAULT_MAX_INLINE_HIGHLIGHT_LINE_LENGTH = 500;
+var DEFAULT_DIFF_TIMEOUT_MS = 100;
+var MAX_INLINE_HIGHLIGHT_LINE_LENGTH = readPositiveIntegerEnv(
+  "BYGONE_MAX_INLINE_HIGHLIGHT_LINE_LENGTH",
+  DEFAULT_MAX_INLINE_HIGHLIGHT_LINE_LENGTH
+);
+var DIFF_TIMEOUT_MS = readPositiveIntegerEnv("BYGONE_DIFF_TIMEOUT_MS", DEFAULT_DIFF_TIMEOUT_MS);
+function buildTwoWayDiffModel(leftContent, rightContent, options = {}) {
+  const leftLines = normalizeLines(leftContent);
+  const rightLines = normalizeLines(rightContent);
+  const changes = diffArrays(leftLines, rightLines, {
+    timeout: options.timeoutMs ?? DIFF_TIMEOUT_MS
+  });
+  if (!changes) {
+    return buildConservativeTwoWayDiffModel(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(makeDiffLine("context", line, leftLineNumber));
+        renderedRightLines.push(makeDiffLine("context", line, rightLineNumber));
+        rows.push(makeDiffRow(
+          makeDiffCell("context", line, leftLineNumber++),
+          makeDiffCell("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 = alignReplacementLines(removedLines, nextChange.value);
+      for (const { left: removedLine, right: addedLine } of alignedLines) {
+        let renderedLeftLine;
+        let renderedRightLine;
+        if (removedLine !== void 0) {
+          renderedLeftLine = makeDiffLine("removed", removedLine, leftLineNumber);
+          renderedLeftLines.push(renderedLeftLine);
+        }
+        if (addedLine !== void 0) {
+          renderedRightLine = makeDiffLine("added", addedLine, rightLineNumber);
+          renderedRightLines.push(renderedRightLine);
+        }
+        if (renderedLeftLine && renderedRightLine) {
+          applyInlineHighlightPair(renderedLeftLine, renderedRightLine);
+        }
+        rows.push(makeDiffRow(
+          removedLine === void 0 ? makePlaceholder() : makeDiffCell("removed", removedLine, leftLineNumber++),
+          addedLine === void 0 ? makePlaceholder() : makeDiffCell("added", addedLine, rightLineNumber++)
+        ));
+      }
+      blocks.push(makeDiffBlock("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(makeDiffLine("removed", line, leftLineNumber));
+        rows.push(makeDiffRow(
+          makeDiffCell("removed", line, leftLineNumber++),
+          makePlaceholder()
+        ));
+      }
+      blocks.push(makeDiffBlock("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(makeDiffLine("added", line, rightLineNumber));
+        rows.push(makeDiffRow(
+          makePlaceholder(),
+          makeDiffCell("added", line, rightLineNumber++)
+        ));
+      }
+      blocks.push(makeDiffBlock("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 buildConservativeTwoWayDiffModel(leftLines, rightLines) {
+  const renderedLeftLines = leftLines.map((line, index) => makeDiffLine("removed", line, index + 1));
+  const renderedRightLines = rightLines.map((line, index) => makeDiffLine("added", line, index + 1));
+  const rows = [
+    ...leftLines.map((line, index) => makeDiffRow(
+      makeDiffCell("removed", line, index + 1),
+      makePlaceholder()
+    )),
+    ...rightLines.map((line, index) => makeDiffRow(
+      makePlaceholder(),
+      makeDiffCell("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 ? [] : [makeDiffBlock(blockKind, 0, leftLines.length, 0, rightLines.length)],
+    hasChanges: rows.length > 0
+  };
+}
+function normalizeLines(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_CELLS = 1e4;
+var MAX_SCORING_LINE_LENGTH = 2e3;
+var MINIMUM_MATCH_SCORE = 0.52;
+var MINIMUM_SINGLE_PAIR_SCORE = 0.35;
+var MINIMUM_CONTEXTUAL_MATCH_SCORE = 0.38;
+var MINIMUM_CONTEXTUAL_RUN_SCORE = 0.33;
+var HIGH_CONFIDENCE_MATCH_SCORE = 0.86;
+var AMBIGUITY_MARGIN = 0.08;
+var CONTEXTUAL_AMBIGUITY_MARGIN = 0.05;
+var GAP_PENALTY = -0.12;
+var MAX_BOUNDED_CANDIDATES = 5e3;
+var MAX_LARGE_HUNK_ANCHORS = 2e3;
+var MAX_RARE_TOKEN_OCCURRENCES = 4;
+var MAX_CONTEXTUAL_HUNK_LINES = 8;
+var MAX_CONTEXTUAL_LENGTH_DELTA = 4;
+function alignReplacementLines(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 = scoreReplacementLinePair(leftLines[0], rightLines[0]);
+    if ((singletonScore.eligible || singletonScore.score >= MINIMUM_SINGLE_PAIR_SCORE) && haveCompatibleLineRoles(leftLines[0], rightLines[0]) && isInformativeLine(normalizeMatchingContent(leftLines[0])) && isInformativeLine(normalizeMatchingContent(rightLines[0]))) {
+      return [{ left: leftLines[0], right: rightLines[0] }];
+    }
+    return [{ left: leftLines[0] }, { right: rightLines[0] }];
+  }
+  if (leftLines.length * rightLines.length > MAX_ALIGNMENT_CELLS) {
+    return alignLargeReplacementLines(leftLines, rightLines);
+  }
+  const pairScores = buildPairScores(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_PENALTY;
+    moves[leftIndex2][0] = "left";
+  }
+  for (let rightIndex2 = 1; rightIndex2 <= rightLines.length; rightIndex2++) {
+    scores[0][rightIndex2] = scores[0][rightIndex2 - 1] + GAP_PENALTY;
+    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_PENALTY },
+        { move: "right", score: scores[leftIndex2][rightIndex2 - 1] + GAP_PENALTY },
+        {
+          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 scoreReplacementLinePair(left, right) {
+  const normalizedLeft = normalizeMatchingContent(left);
+  const normalizedRight = normalizeMatchingContent(right);
+  const leftInformative = isInformativeLine(normalizedLeft);
+  const rightInformative = isInformativeLine(normalizedRight);
+  if (!leftInformative || !rightInformative || normalizedLeft.length > MAX_SCORING_LINE_LENGTH || normalizedRight.length > MAX_SCORING_LINE_LENGTH) {
+    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 = tokenizeMatchingContent(normalizedLeft);
+  const rightTokens = tokenizeMatchingContent(normalizedRight);
+  const characterSimilarity = lineSimilarity(normalizedLeft, normalizedRight);
+  const tokenSimilarity = multisetDiceSimilarity(leftTokens, rightTokens);
+  const lengthSimilarity = Math.min(normalizedLeft.length, normalizedRight.length) / Math.max(normalizedLeft.length, normalizedRight.length);
+  const boundarySimilarity = tokenBoundarySimilarity(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_SCORE,
+    characterSimilarity,
+    tokenSimilarity,
+    lengthSimilarity
+  };
+}
+function buildPairScores(leftLines, rightLines) {
+  const scored = leftLines.map((left) => rightLines.map((right) => scoreReplacementLinePair(left, right)));
+  const structuralPairs = collectUniqueStructuralPairs(leftLines, rightLines);
+  const leftRankings = scored.map((row) => rankEligibleScores(row));
+  const rightRankings = rightLines.map((_right, rightIndex) => rankEligibleScores(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_SCORE ? AMBIGUITY_MARGIN / 2 : AMBIGUITY_MARGIN;
+    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_LINES || Math.abs(leftLines.length - rightLines.length) > MAX_CONTEXTUAL_LENGTH_DELTA) {
+    return accepted;
+  }
+  const isContextualCandidate = (candidate, leftIndex, rightIndex) => candidate.score >= MINIMUM_CONTEXTUAL_MATCH_SCORE && haveCompatibleLineRoles(leftLines[leftIndex], rightLines[rightIndex]) && Math.abs(leftIndex - rightIndex) <= MAX_CONTEXTUAL_LENGTH_DELTA;
+  const leftContextRankings = scored.map((row, leftIndex) => rankScores(row, (candidate, rightIndex) => isContextualCandidate(candidate, leftIndex, rightIndex)));
+  const rightContextRankings = rightLines.map((_right, rightIndex) => rankScores(
+    scored.map((row) => row[rightIndex]),
+    (candidate, leftIndex) => isContextualCandidate(candidate, leftIndex, rightIndex)
+  ));
+  const isWeakRunCandidate = (candidate, leftIndex, rightIndex) => candidate.score >= MINIMUM_CONTEXTUAL_RUN_SCORE && haveCompatibleLineRoles(leftLines[leftIndex], rightLines[rightIndex]) && Math.abs(leftIndex - rightIndex) <= MAX_CONTEXTUAL_LENGTH_DELTA;
+  const leftWeakRankings = scored.map((row, leftIndex) => rankScores(row, (candidate, rightIndex) => isWeakRunCandidate(candidate, leftIndex, rightIndex)));
+  const rightWeakRankings = rightLines.map((_right, rightIndex) => rankScores(
+    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_MARGIN && rightRanking.best - rightRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN;
+  };
+  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_MARGIN && rightRanking.best - rightRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN;
+  };
+  return accepted.map((row, leftIndex) => row.map((acceptedScore, rightIndex) => {
+    if (acceptedScore !== null) {
+      return acceptedScore;
+    }
+    const hasLocalSupport = isUnambiguousContextualCandidate(leftIndex, rightIndex) && (hasAcceptedDiagonalNeighbor(accepted, leftIndex, rightIndex) || hasContextualDiagonalNeighbor(
+      scored,
+      leftIndex,
+      rightIndex,
+      isUnambiguousContextualCandidate
+    ));
+    const hasRunSupport = hasAnchoredWeakDiagonalRun(
+      scored,
+      leftIndex,
+      rightIndex,
+      (candidateLeftIndex, candidateRightIndex) => isWeakRunCandidate(
+        scored[candidateLeftIndex][candidateRightIndex],
+        candidateLeftIndex,
+        candidateRightIndex
+      ),
+      isUnambiguousWeakRunAnchor
+    );
+    if (!hasLocalSupport && !hasRunSupport) {
+      return null;
+    }
+    return scored[leftIndex][rightIndex].score;
+  }));
+}
+function hasAcceptedDiagonalNeighbor(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 hasContextualDiagonalNeighbor(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 hasAnchoredWeakDiagonalRun(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_SCORE && isAnchor(startLeft, startRight) && isAnchor(endLeft, endRight);
+}
+function rankScores(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 rankEligibleScores(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 alignLargeReplacementLines(leftLines, rightLines) {
+  const anchors = collectLargeHunkAnchors(leftLines, rightLines);
+  const aligned = [];
+  let leftStart = 0;
+  let rightStart = 0;
+  for (const anchor of anchors) {
+    appendBoundedSegment(
+      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;
+  }
+  appendBoundedSegment(aligned, leftLines.slice(leftStart), rightLines.slice(rightStart));
+  return aligned;
+}
+function collectLargeHunkAnchors(leftLines, rightLines) {
+  const candidatePairs = collectRareTokenCandidatePairs(leftLines, rightLines);
+  if (candidatePairs === null) {
+    return [];
+  }
+  const structuralPairs = collectUniqueStructuralPairs(leftLines, rightLines);
+  const scored = candidatePairs.map(({ leftIndex, rightIndex, exact }) => ({
+    leftIndex,
+    rightIndex,
+    exact,
+    structural: structuralPairs.has(`${leftIndex}:${rightIndex}`),
+    match: scoreReplacementLinePair(leftLines[leftIndex], rightLines[rightIndex])
+  })).filter((candidate) => candidate.exact || candidate.structural || candidate.match.eligible);
+  const leftRankings = rankAnchorCandidates(scored, "leftIndex");
+  const rightRankings = rankAnchorCandidates(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_SCORE ? AMBIGUITY_MARGIN / 2 : AMBIGUITY_MARGIN;
+    return leftRanking.best - leftRanking.second >= requiredMargin && rightRanking.best - rightRanking.second >= requiredMargin;
+  });
+  const anchors = selectMaximumWeightMonotonicAnchors(confident, rightLines.length);
+  return anchors.length <= MAX_LARGE_HUNK_ANCHORS ? anchors : [];
+}
+function collectRareTokenCandidatePairs(leftLines, rightLines) {
+  const leftExact = buildLinePostings(leftLines, normalizeMatchingContent);
+  const rightExact = buildLinePostings(rightLines, normalizeMatchingContent);
+  const pairs = /* @__PURE__ */ new Map();
+  for (const [line, leftIndices] of leftExact) {
+    const rightIndices = rightExact.get(line);
+    if (!isInformativeLine(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_CANDIDATES) {
+      return null;
+    }
+  }
+  const leftTokens = buildTokenPostings(leftLines);
+  const rightTokens = buildTokenPostings(rightLines);
+  for (const [token, leftIndices] of leftTokens) {
+    const rightIndices = rightTokens.get(token);
+    if (!rightIndices || leftIndices.length > MAX_RARE_TOKEN_OCCURRENCES || rightIndices.length > MAX_RARE_TOKEN_OCCURRENCES) {
+      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_CANDIDATES) {
+            return null;
+          }
+        }
+      }
+    }
+  }
+  return [...pairs.values()];
+}
+function buildLinePostings(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 buildTokenPostings(lines) {
+  const postings = /* @__PURE__ */ new Map();
+  lines.forEach((line, index) => {
+    const tokens = new Set(tokenizeMatchingContent(normalizeMatchingContent(line)).filter(isMeaningfulAnchorToken));
+    for (const token of tokens) {
+      const indices = postings.get(token) ?? [];
+      indices.push(index);
+      postings.set(token, indices);
+    }
+  });
+  return postings;
+}
+function isMeaningfulAnchorToken(token) {
+  return token.length >= 2 && /[\p{L}\p{N}_$]/u.test(token);
+}
+function rankAnchorCandidates(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, rankEligibleScores(scores)]));
+}
+function selectMaximumWeightMonotonicAnchors(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 = queryAnchorTree(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++) {
+      updateAnchorTree(
+        treeScores,
+        treeCandidates,
+        ordered[index].rightIndex + 1,
+        bestScores[index],
+        index
+      );
+    }
+    start = end;
+  }
+  const best = queryAnchorTree(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 queryAnchorTree(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 updateAnchorTree(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 appendBoundedSegment(aligned, leftLines, rightLines) {
+  if (leftLines.length * rightLines.length <= MAX_ALIGNMENT_CELLS) {
+    aligned.push(...alignReplacementLines(leftLines, rightLines));
+    return;
+  }
+  aligned.push(...leftLines.map((left) => ({ left })));
+  aligned.push(...rightLines.map((right) => ({ right })));
+}
+function normalizeMatchingContent(line) {
+  return line.trim().replace(/\s+/g, " ");
+}
+function collectUniqueStructuralPairs(leftLines, rightLines) {
+  const leftPostings = buildStructuralPostings(leftLines);
+  const rightPostings = buildStructuralPostings(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 buildStructuralPostings(lines) {
+  const postings = /* @__PURE__ */ new Map();
+  lines.forEach((line, index) => {
+    const key = declarationAnchorKey(line);
+    if (!key) {
+      return;
+    }
+    const indices = postings.get(key) ?? [];
+    indices.push(index);
+    postings.set(key, indices);
+  });
+  return postings;
+}
+function haveCompatibleLineRoles(left, right) {
+  const leftKey = declarationAnchorKey(left);
+  const rightKey = declarationAnchorKey(right);
+  if (!leftKey || !rightKey) {
+    return leftKey === rightKey;
+  }
+  return leftKey.split(":", 1)[0] === rightKey.split(":", 1)[0];
+}
+function declarationAnchorKey(line) {
+  const normalized = normalizeMatchingContent(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 isInformativeLine(line) {
+  if (line.length < 3) {
+    return false;
+  }
+  return /[\p{L}\p{N}_$]/u.test(line) && !/^[\s()[\]{};,.:+\-*/=>|&!?'"`]+$/.test(line);
+}
+function tokenizeMatchingContent(line) {
+  return line.toLowerCase().match(new RegExp("[\\p{L}_$][\\p{L}\\p{N}_$]*|\\p{N}+(?:\\.\\p{N}+)?|[^\\s\\p{L}\\p{N}_$]", "gu")) ?? [];
+}
+function multisetDiceSimilarity(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 tokenBoundarySimilarity(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 lineSimilarity(left, right) {
+  const maxLength = left.length + right.length;
+  if (maxLength === 0) {
+    return 1;
+  }
+  const commonLength = diffChars(left, right).filter((change) => !change.added && !change.removed).reduce((total, change) => total + change.value.length, 0);
+  return 2 * commonLength / maxLength;
+}
+function applyInlineHighlightPair(leftLine, rightLine) {
+  if (leftLine.content.length > MAX_INLINE_HIGHLIGHT_LINE_LENGTH || rightLine.content.length > MAX_INLINE_HIGHLIGHT_LINE_LENGTH) {
+    return;
+  }
+  const { leftSegments, rightSegments, hasInlineChanges } = buildInlineSegments(leftLine.content, rightLine.content);
+  if (hasInlineChanges) {
+    leftLine.segments = leftSegments;
+    rightLine.segments = rightSegments;
+  }
+}
+function buildInlineSegments(leftContent, rightContent) {
+  const changes = diffWordsWithSpace(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
+      });
+    }
+    if (change.added) {
+      rightSegments.push({
+        kind: "added",
+        text: value,
+        emphasis
+      });
+    }
+  }
+  return {
+    leftSegments,
+    rightSegments,
+    hasInlineChanges
+  };
+}
+function makePlaceholder() {
+  return {
+    kind: "placeholder",
+    content: "",
+    lineNumber: null
+  };
+}
+function makeDiffCell(kind, content, lineNumber) {
+  return { kind, content, lineNumber };
+}
+function makeDiffLine(kind, content, lineNumber) {
+  return { kind, content, lineNumber };
+}
+function makeDiffRow(left, right) {
+  return { left, right };
+}
+function makeDiffBlock(kind, leftStart, leftEnd, rightStart, rightEnd) {
+  return { kind, leftStart, leftEnd, rightStart, rightEnd };
+}
+function readPositiveIntegerEnv(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;
+}
+
+// src/tourAnnotations.ts
+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 {
+    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);
+}
+
 // src/changeTourContext.ts
 var DEFAULT_MAX_PATCH_BYTES = 128 * 1024;
 var DEFAULT_MAX_TOTAL_PATCH_BYTES = 2 * 1024 * 1024;
@@ -1290,7 +2517,8 @@ function applySource(source, defaultScenes, repoRoot) {
           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);
@@ -1316,8 +2544,8 @@ function applySource(source, defaultScenes, repoRoot) {
         takeaway: authoredScene.takeaway,
         steps: authoredScene.steps.map((step) => {
           const focus = requireResolvedAnchor(resolvedAnchors, step.focus);
-          const diff = available.get(focus.path);
-          if (!diff) throw new Error(`Step ${step.id} has no text diff for ${focus.path}.`);
+          const diff2 = available.get(focus.path);
+          if (!diff2) throw new Error(`Step ${step.id} has no text diff for ${focus.path}.`);
           return {
             id: step.id,
             title: step.title,
@@ -1325,7 +2553,7 @@ function applySource(source, defaultScenes, repoRoot) {
             depth: step.depth,
             focus,
             connection: step.connection ? connections.get(step.connection) : void 0,
-            diff: { ...diff, id: `${authoredScene.id}-${step.id}` }
+            diff: { ...diff2, id: `${authoredScene.id}-${step.id}` }
           };
         })
       };
@@ -1336,7 +2564,7 @@ function applySource(source, defaultScenes, repoRoot) {
   }
   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",
@@ -1348,9 +2576,15 @@ function buildDeconstructedManifestScene(repoRoot, source, baseRef, targetRef) {
     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))
@@ -1358,18 +2592,23 @@ function buildDeconstructedManifestScene(repoRoot, source, baseRef, targetRef) {
     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)"}`,
@@ -1378,9 +2617,10 @@ function buildDeconstructedManifestScene(repoRoot, source, baseRef, targetRef) {
           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",
@@ -1398,17 +2638,63 @@ function buildDeconstructedManifestScene(repoRoot, source, baseRef, targetRef) {
     },
     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 = buildTwoWayDiffModel(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,