@aiderdesk/aiderdesk 0.67.0 → 0.69.0

package/out/renderer/assets/{worker-CfJUABHG.js → worker-BdXuKH1Q.js}

@@ -11131,6 +11131,13 @@ function cyrb53(str, seed = 0) {
   h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36).slice(0, 6);
 }
+(() => {
+  try {
+    return false;
+  } catch {
+    return false;
+  }
+})();
 const SPLIT_WITH_NEWLINES = /(?<=\n)/;
 const DEFAULT_THEMES = {
   dark: "pierre-dark",
@@ -11429,6 +11436,22 @@ const EXTENSION_TO_FILE_FORMAT = {
   rst: "rst",
   rake: "ruby",
   gemspec: "ruby",
+  jbuilder: "ruby",
+  builder: "ruby",
+  rabl: "ruby",
+  arb: "ruby",
+  ru: "ruby",
+  podspec: "ruby",
+  Gemfile: "ruby",
+  Rakefile: "ruby",
+  Guardfile: "ruby",
+  Capfile: "ruby",
+  Berksfile: "ruby",
+  Brewfile: "ruby",
+  Vagrantfile: "ruby",
+  Thorfile: "ruby",
+  Appraisals: "ruby",
+  Dangerfile: "ruby",
   sas: "sas",
   sass: "sass",
   scala: "scala",
@@ -11759,14 +11782,83 @@ function getLineNodes(nodes) {
   console.error(nodes);
   throw new Error("getLineNodes: Unable to find children");
 }
+function getExpandedRegion({ isPartial, rangeSize, expandedHunks, hunkIndex, collapsedContextThreshold }) {
+  const normalizedRangeSize = Math.max(rangeSize, 0);
+  if (normalizedRangeSize === 0 || isPartial) return {
+    fromStart: 0,
+    fromEnd: 0,
+    rangeSize: normalizedRangeSize,
+    collapsedLines: normalizedRangeSize,
+    renderAll: false
+  };
+  if (expandedHunks === true || normalizedRangeSize <= collapsedContextThreshold) return {
+    fromStart: normalizedRangeSize,
+    fromEnd: 0,
+    rangeSize: normalizedRangeSize,
+    collapsedLines: 0,
+    renderAll: true
+  };
+  const region = expandedHunks?.get(hunkIndex);
+  const fromStart = Math.min(Math.max(region?.fromStart ?? 0, 0), normalizedRangeSize);
+  const fromEnd = Math.min(Math.max(region?.fromEnd ?? 0, 0), normalizedRangeSize);
+  const expandedCount = fromStart + fromEnd;
+  const renderAll = expandedCount >= normalizedRangeSize;
+  return {
+    fromStart: renderAll ? normalizedRangeSize : fromStart,
+    fromEnd: renderAll ? 0 : fromEnd,
+    rangeSize: normalizedRangeSize,
+    collapsedLines: Math.max(normalizedRangeSize - expandedCount, 0),
+    renderAll
+  };
+}
+function getTrailingContextRangeSize({ fileDiff, errorPrefix }) {
+  const lastHunk = fileDiff.hunks[fileDiff.hunks.length - 1];
+  if (lastHunk == null || fileDiff.isPartial || fileDiff.additionLines.length === 0 || fileDiff.deletionLines.length === 0) return 0;
+  const additionRemaining = fileDiff.additionLines.length - (lastHunk.additionLineIndex + lastHunk.additionCount);
+  const deletionRemaining = fileDiff.deletionLines.length - (lastHunk.deletionLineIndex + lastHunk.deletionCount);
+  if (additionRemaining <= 0 && deletionRemaining <= 0) return 0;
+  if (additionRemaining !== deletionRemaining) throw new Error(`${errorPrefix}: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${fileDiff.name}`);
+  return Math.min(additionRemaining, deletionRemaining);
+}
+function getTrailingExpandedRegion({ fileDiff, hunkIndex, expandedHunks, collapsedContextThreshold, errorPrefix }) {
+  if (hunkIndex !== fileDiff.hunks.length - 1) return;
+  const trailingRangeSize = getTrailingContextRangeSize({
+    fileDiff,
+    errorPrefix
+  });
+  if (trailingRangeSize <= 0) return;
+  if (expandedHunks === true || trailingRangeSize <= collapsedContextThreshold) return {
+    fromStart: trailingRangeSize,
+    fromEnd: 0,
+    rangeSize: trailingRangeSize,
+    collapsedLines: 0,
+    renderAll: true
+  };
+  const region = expandedHunks?.get(fileDiff.hunks.length);
+  const fromStart = Math.min(Math.max(region?.fromStart ?? 0, 0), trailingRangeSize);
+  return {
+    fromStart,
+    fromEnd: 0,
+    rangeSize: trailingRangeSize,
+    collapsedLines: trailingRangeSize - fromStart,
+    renderAll: fromStart >= trailingRangeSize
+  };
+}
 function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infinity, expandedHunks, collapsedContextThreshold = DEFAULT_COLLAPSED_CONTEXT_THRESHOLD, callback }) {
+  const iterationStart = getIterationStartState({
+    diff,
+    diffStyle,
+    startingLine,
+    expandedHunks,
+    collapsedContextThreshold
+  });
   const state = {
-    finalHunk: diff.hunks.at(-1),
     viewportStart: startingLine,
     viewportEnd: startingLine + totalLines,
     isWindowedHighlight: startingLine > 0 || totalLines < Infinity,
-    splitCount: 0,
-    unifiedCount: 0,
+    splitCount: iterationStart.splitCount,
+    unifiedCount: iterationStart.unifiedCount,
+    finalHunkIndex: diff.hunks.length - 1,
     shouldBreak() {
       if (!state.isWindowedHighlight) return false;
       const breakUnified = state.unifiedCount >= startingLine + totalLines;
@@ -11800,28 +11892,34 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
       return callback(props) ?? false;
     }
   };
-  hunkIterator: for (const [hunkIndex, hunk] of diff.hunks.entries()) {
-    let getTrailingCollapsedAfter2 = function(unifiedLineIndex$1, splitLineIndex$1) {
+  hunkIterator: for (let hunkIndex = iterationStart.hunkIndex; hunkIndex < diff.hunks.length; hunkIndex++) {
+    let getTrailingCollapsedAfter = function(unifiedLineIndex$1, splitLineIndex$1) {
       if (trailingRegion == null || trailingRegion.collapsedLines <= 0 || trailingRegion.fromStart + trailingRegion.fromEnd > 0) return 0;
       return splitLineIndex$1 === hunk.splitLineStart + hunk.splitLineCount - 1 ? trailingRegion.collapsedLines : 0;
-    }, getPendingCollapsed2 = function() {
-      if (leadingRegion.collapsedLines === 0) return 0;
-      const value = leadingRegion.collapsedLines;
-      leadingRegion.collapsedLines = 0;
-      return value;
+    }, consumePendingCollapsed = function() {
+      if (consumedCollapsed) return 0;
+      consumedCollapsed = true;
+      return leadingRegion.collapsedLines;
     };
-    var getTrailingCollapsedAfter = getTrailingCollapsedAfter2, getPendingCollapsed = getPendingCollapsed2;
+    const hunk = diff.hunks[hunkIndex];
+    if (hunk == null) throw new Error("iterateOverDiff: invalid hunk index");
     if (state.shouldBreak()) break;
-    const leadingRegion = getExpandedRegion(diff.isPartial, hunk.collapsedBefore, expandedHunks, hunkIndex, collapsedContextThreshold);
-    const trailingRegion = (() => {
-      if (hunk !== state.finalHunk || !hasFinalCollapsedHunk(diff)) return;
-      const additionRemaining = diff.additionLines.length - (hunk.additionLineIndex + hunk.additionCount);
-      const deletionRemaining = diff.deletionLines.length - (hunk.deletionLineIndex + hunk.deletionCount);
-      if (additionRemaining !== deletionRemaining) throw new Error(`iterateOverDiff: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${diff.name}`);
-      const trailingRangeSize = Math.min(additionRemaining, deletionRemaining);
-      return getExpandedRegion(diff.isPartial, trailingRangeSize, expandedHunks, diff.hunks.length, collapsedContextThreshold);
-    })();
+    const leadingRegion = getExpandedRegion({
+      isPartial: diff.isPartial,
+      rangeSize: hunk.collapsedBefore,
+      expandedHunks,
+      hunkIndex,
+      collapsedContextThreshold
+    });
+    const trailingRegion = hunkIndex === state.finalHunkIndex ? getTrailingExpandedRegion({
+      fileDiff: diff,
+      hunkIndex,
+      expandedHunks,
+      collapsedContextThreshold,
+      errorPrefix: "iterateOverDiff"
+    }) : void 0;
     const expandedLineCount = leadingRegion.fromStart + leadingRegion.fromEnd;
+    let consumedCollapsed = leadingRegion.collapsedLines === 0;
     if (!state.shouldSkip(expandedLineCount, expandedLineCount)) {
       let unifiedLineIndex$1 = hunk.unifiedLineStart - leadingRegion.rangeSize;
       let splitLineIndex$1 = hunk.splitLineStart - leadingRegion.rangeSize;
@@ -11829,69 +11927,63 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
       let additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.rangeSize;
       let deletionLineNumber$1 = hunk.deletionStart - leadingRegion.rangeSize;
       let additionLineNumber$1 = hunk.additionStart - leadingRegion.rangeSize;
-      let index = 0;
-      while (index < leadingRegion.fromStart) {
-        if (state.isInWindow(0, 0)) {
-          if (state.emit({
-            hunkIndex,
-            hunk,
-            collapsedBefore: 0,
-            collapsedAfter: 0,
-            type: "context-expanded",
-            deletionLine: {
-              lineNumber: deletionLineNumber$1 + index,
-              lineIndex: deletionLineIndex$1 + index,
-              noEOFCR: false,
-              unifiedLineIndex: unifiedLineIndex$1 + index,
-              splitLineIndex: splitLineIndex$1 + index
-            },
-            additionLine: {
-              unifiedLineIndex: unifiedLineIndex$1 + index,
-              splitLineIndex: splitLineIndex$1 + index,
-              lineIndex: additionLineIndex$1 + index,
-              lineNumber: additionLineNumber$1 + index,
-              noEOFCR: false
-            }
-          })) break hunkIterator;
-        } else state.incrementCounts(1, 1);
-        index++;
-      }
+      if (walkContextLines(state, leadingRegion.fromStart, diffStyle, (index) => {
+        return state.emit({
+          hunkIndex,
+          hunk,
+          collapsedBefore: 0,
+          collapsedAfter: 0,
+          type: "context-expanded",
+          deletionLine: {
+            lineNumber: deletionLineNumber$1 + index,
+            lineIndex: deletionLineIndex$1 + index,
+            noEOFCR: false,
+            unifiedLineIndex: unifiedLineIndex$1 + index,
+            splitLineIndex: splitLineIndex$1 + index
+          },
+          additionLine: {
+            unifiedLineIndex: unifiedLineIndex$1 + index,
+            splitLineIndex: splitLineIndex$1 + index,
+            lineIndex: additionLineIndex$1 + index,
+            lineNumber: additionLineNumber$1 + index,
+            noEOFCR: false
+          }
+        });
+      })) break hunkIterator;
       unifiedLineIndex$1 = hunk.unifiedLineStart - leadingRegion.fromEnd;
       splitLineIndex$1 = hunk.splitLineStart - leadingRegion.fromEnd;
       deletionLineIndex$1 = hunk.deletionLineIndex - leadingRegion.fromEnd;
       additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.fromEnd;
       deletionLineNumber$1 = hunk.deletionStart - leadingRegion.fromEnd;
       additionLineNumber$1 = hunk.additionStart - leadingRegion.fromEnd;
-      index = 0;
-      while (index < leadingRegion.fromEnd) {
-        if (state.isInWindow(0, 0)) {
-          if (state.emit({
-            hunkIndex,
-            hunk,
-            collapsedBefore: getPendingCollapsed2(),
-            collapsedAfter: 0,
-            type: "context-expanded",
-            deletionLine: {
-              lineNumber: deletionLineNumber$1 + index,
-              lineIndex: deletionLineIndex$1 + index,
-              noEOFCR: false,
-              unifiedLineIndex: unifiedLineIndex$1 + index,
-              splitLineIndex: splitLineIndex$1 + index
-            },
-            additionLine: {
-              unifiedLineIndex: unifiedLineIndex$1 + index,
-              splitLineIndex: splitLineIndex$1 + index,
-              lineIndex: additionLineIndex$1 + index,
-              lineNumber: additionLineNumber$1 + index,
-              noEOFCR: false
-            }
-          })) break hunkIterator;
-        } else state.incrementCounts(1, 1);
-        index++;
-      }
+      if (walkContextLines(state, leadingRegion.fromEnd, diffStyle, (index) => {
+        return state.emit({
+          hunkIndex,
+          hunk,
+          collapsedBefore: consumePendingCollapsed(),
+          collapsedAfter: 0,
+          type: "context-expanded",
+          deletionLine: {
+            lineNumber: deletionLineNumber$1 + index,
+            lineIndex: deletionLineIndex$1 + index,
+            noEOFCR: false,
+            unifiedLineIndex: unifiedLineIndex$1 + index,
+            splitLineIndex: splitLineIndex$1 + index
+          },
+          additionLine: {
+            unifiedLineIndex: unifiedLineIndex$1 + index,
+            splitLineIndex: splitLineIndex$1 + index,
+            lineIndex: additionLineIndex$1 + index,
+            lineNumber: additionLineNumber$1 + index,
+            noEOFCR: false
+          }
+        });
+      }, () => {
+        consumePendingCollapsed();
+      })) break hunkIterator;
     } else {
       state.incrementCounts(expandedLineCount, expandedLineCount);
-      getPendingCollapsed2();
+      consumePendingCollapsed();
     }
     let unifiedLineIndex = hunk.unifiedLineStart;
     let splitLineIndex = hunk.splitLineStart;
@@ -11905,39 +11997,37 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
       const isLastContent = content === lastContent;
       if (content.type === "context") {
         if (!state.shouldSkip(content.lines, content.lines)) {
-          let index = 0;
-          while (index < content.lines) {
-            if (state.isInWindow(0, 0)) {
-              const isLastLine = isLastContent && index === content.lines - 1;
-              const unifiedRowIndex = unifiedLineIndex + index;
-              const splitRowIndex = splitLineIndex + index;
-              if (state.emit({
-                hunkIndex,
-                hunk,
-                collapsedBefore: getPendingCollapsed2(),
-                collapsedAfter: getTrailingCollapsedAfter2(unifiedRowIndex, splitRowIndex),
-                type: "context",
-                deletionLine: {
-                  lineNumber: deletionLineNumber + index,
-                  lineIndex: deletionLineIndex + index,
-                  noEOFCR: isLastLine && hunk.noEOFCRDeletions,
-                  unifiedLineIndex: unifiedRowIndex,
-                  splitLineIndex: splitRowIndex
-                },
-                additionLine: {
-                  unifiedLineIndex: unifiedRowIndex,
-                  splitLineIndex: splitRowIndex,
-                  lineIndex: additionLineIndex + index,
-                  lineNumber: additionLineNumber + index,
-                  noEOFCR: isLastLine && hunk.noEOFCRAdditions
-                }
-              })) break hunkIterator;
-            } else state.incrementCounts(1, 1);
-            index++;
-          }
+          if (walkContextLines(state, content.lines, diffStyle, (index) => {
+            const isLastLine = isLastContent && index === content.lines - 1;
+            const unifiedRowIndex = unifiedLineIndex + index;
+            const splitRowIndex = splitLineIndex + index;
+            return state.emit({
+              hunkIndex,
+              hunk,
+              collapsedBefore: consumePendingCollapsed(),
+              collapsedAfter: getTrailingCollapsedAfter(unifiedRowIndex, splitRowIndex),
+              type: "context",
+              deletionLine: {
+                lineNumber: deletionLineNumber + index,
+                lineIndex: deletionLineIndex + index,
+                noEOFCR: isLastLine && hunk.noEOFCRDeletions,
+                unifiedLineIndex: unifiedRowIndex,
+                splitLineIndex: splitRowIndex
+              },
+              additionLine: {
+                unifiedLineIndex: unifiedRowIndex,
+                splitLineIndex: splitRowIndex,
+                lineIndex: additionLineIndex + index,
+                lineNumber: additionLineNumber + index,
+                noEOFCR: isLastLine && hunk.noEOFCRAdditions
+              }
+            });
+          }, () => {
+            consumePendingCollapsed();
+          })) break hunkIterator;
         } else {
           state.incrementCounts(content.lines, content.lines);
-          getPendingCollapsed2();
+          consumePendingCollapsed();
         }
         unifiedLineIndex += content.lines;
         splitLineIndex += content.lines;
@@ -11950,12 +12040,13 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
         const unifiedCount = content.deletions + content.additions;
         if (!state.shouldSkip(unifiedCount, splitCount)) {
           const iterationRanges = getChangeIterationRanges(state, content);
+          if ((iterationRanges[0]?.[0] ?? 0) > 0) consumePendingCollapsed();
           for (const [rangeStart, rangeEnd] of iterationRanges) for (let index = rangeStart; index < rangeEnd; index++) {
-            const collapsedAfter = getTrailingCollapsedAfter2(unifiedLineIndex + index, splitLineIndex + index);
+            const collapsedAfter = getTrailingCollapsedAfter(unifiedLineIndex + index, splitLineIndex + index);
             if (state.emit(getChangeLineData({
               hunkIndex,
               hunk,
-              collapsedBefore: getPendingCollapsed2(),
+              collapsedBefore: consumePendingCollapsed(),
               collapsedAfter,
               diffStyle,
               index,
@@ -11972,7 +12063,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
             }), true)) break hunkIterator;
           }
         }
-        getPendingCollapsed2();
+        consumePendingCollapsed();
         state.incrementCounts(unifiedCount, splitCount);
         unifiedLineIndex += unifiedCount;
         splitLineIndex += splitCount;
@@ -11985,68 +12076,79 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     if (trailingRegion != null) {
       const { collapsedLines, fromStart, fromEnd } = trailingRegion;
       const len = fromStart + fromEnd;
-      let index = 0;
-      while (index < len) {
-        if (state.shouldBreak()) break hunkIterator;
-        if (state.isInWindow(0, 0)) {
-          const isLastLine = index === len - 1;
-          if (state.emit({
-            hunkIndex: diff.hunks.length,
-            hunk: void 0,
-            collapsedBefore: 0,
-            collapsedAfter: isLastLine ? collapsedLines : 0,
-            type: "context-expanded",
-            deletionLine: {
-              lineNumber: deletionLineNumber + index,
-              lineIndex: deletionLineIndex + index,
-              noEOFCR: false,
-              unifiedLineIndex: unifiedLineIndex + index,
-              splitLineIndex: splitLineIndex + index
-            },
-            additionLine: {
-              unifiedLineIndex: unifiedLineIndex + index,
-              splitLineIndex: splitLineIndex + index,
-              lineIndex: additionLineIndex + index,
-              lineNumber: additionLineNumber + index,
-              noEOFCR: false
-            }
-          })) break hunkIterator;
-        } else state.incrementCounts(1, 1);
-        index++;
-      }
+      if (walkContextLines(state, len, diffStyle, (index) => {
+        const isLastLine = index === len - 1;
+        return state.emit({
+          hunkIndex: diff.hunks.length,
+          hunk: void 0,
+          collapsedBefore: 0,
+          collapsedAfter: isLastLine ? collapsedLines : 0,
+          type: "context-expanded",
+          deletionLine: {
+            lineNumber: deletionLineNumber + index,
+            lineIndex: deletionLineIndex + index,
+            noEOFCR: false,
+            unifiedLineIndex: unifiedLineIndex + index,
+            splitLineIndex: splitLineIndex + index
+          },
+          additionLine: {
+            unifiedLineIndex: unifiedLineIndex + index,
+            splitLineIndex: splitLineIndex + index,
+            lineIndex: additionLineIndex + index,
+            lineNumber: additionLineNumber + index,
+            noEOFCR: false
+          }
+        });
+      }, void 0, () => state.shouldBreak())) break hunkIterator;
     }
   }
 }
-function getExpandedRegion(isPartial, rangeSize, expandedHunks, hunkIndex, collapsedContextThreshold) {
-  rangeSize = Math.max(rangeSize, 0);
-  if (rangeSize === 0 || isPartial) return {
-    fromStart: 0,
-    fromEnd: 0,
-    rangeSize,
-    collapsedLines: Math.max(rangeSize, 0)
-  };
-  if (expandedHunks === true || rangeSize <= collapsedContextThreshold) return {
-    fromStart: rangeSize,
-    fromEnd: 0,
-    rangeSize,
-    collapsedLines: 0
-  };
-  const region = expandedHunks?.get(hunkIndex);
-  const fromStart = Math.min(Math.max(region?.fromStart ?? 0, 0), rangeSize);
-  const fromEnd = Math.min(Math.max(region?.fromEnd ?? 0, 0), rangeSize);
-  const expandedCount = fromStart + fromEnd;
-  const renderAll = expandedCount >= rangeSize;
+function getIterationStartState({ diff, diffStyle, startingLine, expandedHunks, collapsedContextThreshold }) {
   return {
-    fromStart: renderAll ? rangeSize : fromStart,
-    fromEnd: renderAll ? 0 : fromEnd,
-    rangeSize,
-    collapsedLines: Math.max(rangeSize - expandedCount, 0)
+    hunkIndex: 0,
+    splitCount: 0,
+    unifiedCount: 0
   };
 }
-function hasFinalCollapsedHunk(diff) {
-  const lastHunk = diff.hunks.at(-1);
-  if (lastHunk == null || diff.isPartial || diff.additionLines.length === 0 || diff.deletionLines.length === 0) return false;
-  return lastHunk.additionLineIndex + lastHunk.additionCount < diff.additionLines.length || lastHunk.deletionLineIndex + lastHunk.deletionCount < diff.deletionLines.length;
+function getContextLineIterationBounds(state, count, diffStyle) {
+  if (!state.isWindowedHighlight || count <= 0) return [0, count];
+  const ranges = [];
+  function pushRange(currentCount) {
+    const start$1 = Math.max(0, state.viewportStart - currentCount);
+    const end$1 = Math.min(count, state.viewportEnd - currentCount);
+    if (end$1 > start$1) ranges.push([start$1, end$1]);
+  }
+  pushRange(state.unifiedCount);
+  pushRange(state.splitCount);
+  if (ranges.length === 0) return [0, 0];
+  let start = ranges[0][0];
+  let end = ranges[0][1];
+  for (let index = 1; index < ranges.length; index++) {
+    const range2 = ranges[index];
+    start = Math.min(start, range2[0]);
+    end = Math.max(end, range2[1]);
+  }
+  return [start, end];
+}
+function walkContextLines(state, count, diffStyle, callback, onSkippedStart, shouldBreak) {
+  const [startIndex, endIndex] = getContextLineIterationBounds(state, count);
+  if (startIndex > 0) {
+    state.incrementCounts(startIndex, startIndex);
+    onSkippedStart?.();
+  }
+  let index = startIndex;
+  while (index < count) {
+    if (shouldBreak?.() === true) return true;
+    if (index >= endIndex) {
+      state.incrementCounts(count - index, count - index);
+      break;
+    }
+    if (state.isInWindow(0, 0)) {
+      if (callback(index) === true) return true;
+    } else state.incrementCounts(1, 1);
+    index++;
+  }
+  return false;
 }
 function getChangeIterationRanges(state, content, diffStyle) {
   if (!state.isWindowedHighlight) return [[0, Math.max(content.deletions, content.additions)]];
@@ -12085,14 +12187,14 @@ function getChangeIterationRanges(state, content, diffStyle) {
 }
 function getChangeLineData({ hunkIndex, hunk, collapsedAfter, collapsedBefore, diffStyle, index, unifiedLineIndex, splitLineIndex, additionLineIndex, deletionLineIndex, additionLineNumber, deletionLineNumber, content, isLastContent, unifiedCount, splitCount }) {
   const unifiedDeletionLineIndex = index < content.deletions ? unifiedLineIndex + index : void 0;
-  const unifiedAdditionLineIndex = index < content.additions ? unifiedLineIndex + content.deletions + index : void 0;
-  const resolvedSplitLineIndex = splitLineIndex + index;
+  const unifiedAdditionLineIndex = diffStyle === "unified" ? index >= content.deletions ? unifiedLineIndex + index : void 0 : index < content.additions ? unifiedLineIndex + content.deletions + index : void 0;
+  const resolvedSplitLineIndex = diffStyle === "unified" ? splitLineIndex + (index < content.deletions ? index : index - content.deletions) : splitLineIndex + index;
   const deletionLineIndexValue = index < content.deletions ? deletionLineIndex + index : void 0;
   const deletionLineNumberValue = index < content.deletions ? deletionLineNumber + index : void 0;
-  const additionLineIndexValue = index < content.additions ? additionLineIndex + index : void 0;
-  const additionLineNumberValue = index < content.additions ? additionLineNumber + index : void 0;
-  const noEOFCRDeletion = isLastContent && index === splitCount - 1 && hunk.noEOFCRDeletions;
-  const noEOFCRAddition = isLastContent && index === splitCount - 1 && hunk.noEOFCRAdditions;
+  const additionLineIndexValue = diffStyle === "unified" ? index >= content.deletions ? additionLineIndex + (index - content.deletions) : void 0 : index < content.additions ? additionLineIndex + index : void 0;
+  const additionLineNumberValue = diffStyle === "unified" ? index >= content.deletions ? additionLineNumber + (index - content.deletions) : void 0 : index < content.additions ? additionLineNumber + index : void 0;
+  const noEOFCRDeletion = diffStyle === "unified" ? isLastContent && index === content.deletions - 1 && hunk.noEOFCRDeletions : isLastContent && index === splitCount - 1 && hunk.noEOFCRDeletions;
+  const noEOFCRAddition = diffStyle === "unified" ? isLastContent && index === unifiedCount - 1 && hunk.noEOFCRAdditions : isLastContent && index === splitCount - 1 && hunk.noEOFCRAdditions;
   const deletionLine = deletionLineIndexValue != null && deletionLineNumberValue != null && unifiedDeletionLineIndex != null ? {
     lineNumber: deletionLineNumberValue,
     lineIndex: deletionLineIndexValue,
@@ -12526,6 +12628,7 @@ async function handleMessage(request) {
   } catch (error) {
     console.error("Worker error:", error);
     sendError(request.id, error);
+  } finally {
   }
 }
 async function handleInitialize({ id, renderOptions: options, preferredHighlighter, resolvedThemes, resolvedLanguages, customExtensionsVersion: customExtensionsVersion$1, customExtensionMap }) {

package/out/renderer/assets/{xychartDiagram-2RQKCTM6-CKvwGbhk.js → xychartDiagram-2RQKCTM6-PJZgkel8.js}

@@ -1,4 +1,4 @@
-import { s as setAccDescription, g as getAccDescription, q as getDiagramTitle, p as setDiagramTitle, a as getAccTitle, b as setAccTitle, _ as __name, l as log, I as selectSvgElement, e as configureSvgSize, z as clear, D as getConfig, i as sanitizeText, F as cleanAndMerge, G as defaultConfig_default, L as getThemeVariables3, M as band, N as computeDimensionOfText, K as linear, O as line } from "./index-P63PgYUG.js";
+import { s as setAccDescription, g as getAccDescription, q as getDiagramTitle, p as setDiagramTitle, a as getAccTitle, b as setAccTitle, _ as __name, l as log, I as selectSvgElement, e as configureSvgSize, z as clear, D as getConfig, i as sanitizeText, F as cleanAndMerge, G as defaultConfig_default, L as getThemeVariables3, M as band, N as computeDimensionOfText, K as linear, O as line } from "./index-COTYjomB.js";
 var parser = (function() {
   var o = /* @__PURE__ */ __name(function(k, v, o2, l) {
     for (o2 = o2 || {}, l = k.length; l--; o2[k[l]] = v) ;

package/out/renderer/index.html

@@ -20,8 +20,8 @@
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
     <meta name="apple-mobile-web-app-title" content="AiderDesk">
     <link rel="apple-touch-icon" href="/icon-192.png">
-    <script type="module" crossorigin src="./assets/index-P63PgYUG.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-zdiQSGqQ.css">
+    <script type="module" crossorigin src="./assets/index-COTYjomB.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-D56aByCg.css">
   </head>
 
   <body>

package/out/resources/skills/extension-creator/SKILL.md

@@ -112,6 +112,20 @@ Do not use when:
 
 **If:** Component triggers actions, implement `executeUIExtensionAction()`
 
+### Rule: Use external libraries when UI components need npm packages
+
+**When:** Extension UI components need third-party npm packages (charts, calendars, kanban boards, etc.)
+
+**Then:** Implement `getUIComponentsLibraries()` returning a Record<string, string> mapping camelCase keys to npm package specs
+
+**Must:** Access loaded libraries in JSX via `props.libraries.<key>`
+
+**Must:** Handle the loading state — libraries are async and `props.libraries.<key>` will be `undefined` on first render
+
+**Never:** Bundle or import React in library specs — AiderDesk's React instance is externalized automatically
+
+**Reference:** [external-libraries.md](references/external-libraries.md) for full details, loading patterns, and examples
+
 ### Rule: Add config component for extension settings
 
 **When:** Extension needs user-configurable settings (shown in gear icon dialog)
@@ -295,6 +309,15 @@ After completing this skill, verify:
   }
   ```
 
+**Situation:** Extension UI components need third-party npm packages
+
+**Pattern:**
+- When: Extension needs a library like a chart, calendar, kanban board, etc. that isn't in the built-in `ui` prop
+- Then: Implement `getUIComponentsLibraries()` returning `{ key: 'package@^version' }`
+- Access: Use `props.libraries.<key>` in JSX — check for `undefined` (async loading)
+- Example: `getUIComponentsLibraries() { return { chart: 'recharts@^2.12.0' } }`
+- Reference: [external-libraries.md](references/external-libraries.md)
+
 **Situation:** Extension needs config storage
 
 **Pattern:**
@@ -331,6 +354,7 @@ After completing this skill, verify:
 - [event-types.md](references/event-types.md) - All event types and payloads
 - [command-definition.md](references/command-definition.md) - Command structure
 - [ui-components.md](references/ui-components.md) - UI component system, placements, and available components
+- [external-libraries.md](references/external-libraries.md) - Loading third-party npm libraries in UI components (getUIComponentsLibraries)
 - [config-components.md](references/config-components.md) - Config component API (settings UI), methods, JSX format, and patterns
 - [examples-gallery.md](references/examples-gallery.md) - Real extension examples
 

package/out/resources/skills/extension-creator/references/examples-gallery.md

@@ -581,3 +581,14 @@ export default class ExternalRulesExtension implements Extension {
 | Tools | chunkhound-search | Custom AI tools |
 | UI Display | tps-counter | Show information in UI |
 | UI Interactive | multi-model-run | User input in UI |
+| **External Libraries** | **kanban-demo.ts** | **Third-party npm packages in UI components** |
+
+### External Libraries (kanban-demo.ts)
+
+Uses `getUIComponentsLibraries()` to load a npm package and render it in a UI component. See [external-libraries.md](external-libraries.md) for full documentation and a minimal example.
+
+Key patterns:
+- `getUIComponentsLibraries()` returns `{ kanban: 'react-kanban-kit@^0.0.2-beta.7' }`
+- JSX accesses library via `props.libraries.kanban`
+- Loading state handled with `undefined` check + timeout-based error fallback
+- Uses `ui.Button` and `ui.ModalOverlayLayout` alongside the external library

package/out/resources/skills/extension-creator/references/extension-interface.md

@@ -16,6 +16,7 @@ interface Extension {
   getAgents?(context: ExtensionContext): AgentProfile[];
   getModes?(context: ExtensionContext): ModeDefinition[];
   getUIComponents?(context: ExtensionContext): UIComponentDefinition[];
+  getUIComponentsLibraries?(): Record<string, string>;
   
   // UI Component support
   getUIExtensionData?(componentId: string, context: ExtensionContext): Promise<unknown>;
@@ -250,6 +251,9 @@ interface UIComponentProps {
   // Extension actions
   executeExtensionAction: (action: string, ...args: unknown[]) => Promise<unknown>;
   
+  // External libraries (loaded via getUIComponentsLibraries)
+  libraries: Record<string, Record<string, unknown>>;
+  
   // Data from getUIExtensionData() (if loadData: true)
   data?: unknown;