typebulb 0.49.1 → 0.49.2

package/dist/agents/pi/matchu-patchu.ts

@@ -1,2567 +0,0 @@
-// Generated by typebulb — do not edit; overwritten on each typebulb run.
-
-// cli/agents/pi/server/piPatcherExtension.ts
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { Type } from "typebox";
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/utils/textUtils.js
-var TextUtils = class _TextUtils {
-  static NormalizeToLf(text) {
-    return (text ?? "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-  }
-  static DetectNewline(text) {
-    if (!text || text.length === 0)
-      return "\n";
-    const idx = text.search(/[\r\n]/);
-    if (idx < 0)
-      return "\n";
-    return text[idx] === "\r" ? idx + 1 < text.length && text[idx + 1] === "\n" ? "\r\n" : "\r" : "\n";
-  }
-  /// <summary>Normalize + split to LF-only lines.</summary>
-  static ToLines(text) {
-    return _TextUtils.NormalizeToLf(text).split("\n");
-  }
-  /// <summary>Count of leading characters drawn from `chars` (default: space or tab).</summary>
-  static CountLeadingWhitespace(s, chars = " 	") {
-    let i = 0;
-    while (i < s.length && chars.includes(s[i]))
-      i++;
-    return i;
-  }
-  /// <summary>Maps chat-layer typography (smart quotes, Unicode dashes, special
-  /// spaces) to ASCII. Match-only: output text is never built from this.
-  /// Numeric code points throughout: invisible/lookalike literals would make this
-  /// file unmatchable by byte-exact edit tools, including this patcher's own MCP.</summary>
-  static NormalizeHomoglyphs(line) {
-    return [...line].some((c) => c.charCodeAt(0) >= 160) ? [...line].map((c) => _TextUtils.MapHomoglyph(c)).join("") : line;
-  }
-  static MapHomoglyph(c) {
-    const cp = c.codePointAt(0);
-    if (cp >= 8216 && cp <= 8219)
-      return "'";
-    if (cp >= 8220 && cp <= 8223)
-      return '"';
-    if (cp >= 8208 && cp <= 8213 || cp === 8722)
-      return "-";
-    if (cp === 160 || cp >= 8194 && cp <= 8202 || cp === 8239 || cp === 8287 || cp === 12288)
-      return " ";
-    return c;
-  }
-  /// <summary>Removes zero-width/control code points for match-tolerant
-  /// comparison. Match-only, like NormalizeHomoglyphs: output text is never
-  /// built from this.</summary>
-  static StripInvisibles(line) {
-    return [...line].some((c) => _TextUtils.IsInvisible(c)) ? [...line].filter((c) => !_TextUtils.IsInvisible(c)).join("") : line;
-  }
-  /// <summary>Folds NFC canonical equivalence and fullwidth ASCII forms
-  /// (U+FF01..U+FF5E) for match-tolerant comparison. Match-only, like
-  /// NormalizeHomoglyphs. The NFKC compat remainder (ligatures, superscripts)
-  /// stays unfolded: visually distinct content must not cross-match.</summary>
-  static FoldCanonicalAndFullwidth(line) {
-    if (![...line].some((c) => c.charCodeAt(0) >= 768))
-      return line;
-    const folded = [...line].map((c) => {
-      const cp = c.charCodeAt(0);
-      return cp >= 65281 && cp <= 65374 ? String.fromCharCode(cp - 65248) : c;
-    }).join("");
-    return _TextUtils.HasUnpairedSurrogate(folded) ? folded : folded.normalize("NFC");
-  }
-  static HasUnpairedSurrogate(s) {
-    for (let i = 0; i < s.length; i++) {
-      const cp = s.charCodeAt(i);
-      if (cp < 55296 || cp > 57343)
-        continue;
-      const next = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;
-      if (cp > 56319 || next < 56320 || next > 57343)
-        return true;
-      i++;
-    }
-    return false;
-  }
-  // Zero-width/control code points that render as nothing (or reorder text):
-  // the classes JSON-escape mangling degrades into. Tab excluded: real content.
-  // Numeric code points, not escapes or literals: they survive tool boundaries
-  // that decode backslash escapes or eat raw control chars.
-  static IsInvisible(c) {
-    const cp = c.codePointAt(0);
-    if (cp === 9)
-      return false;
-    return cp < 32 || cp >= 127 && cp <= 159 || cp === 173 || cp === 1564 || cp === 6158 || cp >= 8203 && cp <= 8207 || cp >= 8234 && cp <= 8238 || cp >= 8288 && cp <= 8292 || cp >= 8294 && cp <= 8297 || cp === 65279;
-  }
-  // En/em dashes are exempt from the audit: this authoring stack emits them in all
-  // comment prose, so warning on them fires on nearly every apply and trains readers
-  // to skip the audit (warning-blindness). They stay in the homoglyph table, so match
-  // tolerance is unchanged. Curly quotes still warn: the motivating mangle was a quote
-  // lookalike inside code, and prose here uses straight quotes — a curly quote is more
-  // likely damage than intent.
-  static IsIntentionalTypography(c) {
-    const cp = c.codePointAt(0);
-    return cp === 8211 || cp === 8212;
-  }
-  /// <summary>Names the invisible/lookalike code points in the given lines, or null if
-  /// there are none. Escape mangling at a tool-call boundary writes unintended bytes
-  /// silently; intent is unrecoverable afterwards, so the audit states the facts (which
-  /// code point, what it resembles, how many) and leaves the judgment to the caller.
-  /// </summary>
-  static DescribeSuspectCodePoints(lines) {
-    const counts = /* @__PURE__ */ new Map();
-    for (const line of lines)
-      for (const c of line)
-        if (_TextUtils.IsInvisible(c) || _TextUtils.MapHomoglyph(c) !== c && !_TextUtils.IsIntentionalTypography(c))
-          counts.set(c, (counts.get(c) ?? 0) + 1);
-    if (counts.size === 0)
-      return null;
-    return [...counts.entries()].sort((a, b) => a[0].codePointAt(0) - b[0].codePointAt(0)).map(([c, n]) => {
-      const mapped = _TextUtils.MapHomoglyph(c);
-      const what = _TextUtils.IsInvisible(c) ? "invisible" : mapped === " " ? "looks like a space" : `looks like ${mapped}`;
-      const hex = c.codePointAt(0).toString(16).toUpperCase().padStart(4, "0");
-      return `U+${hex} (${what}) x${n}`;
-    }).join(", ");
-  }
-  /// <summary>Round-trip variant that accepts updated LF lines.</summary>
-  static RoundTripWhitespace(originalSnapshot, updatedLines) {
-    const joined = updatedLines.join("\n");
-    const origHadTrailing = originalSnapshot.endsWith("\n") || originalSnapshot.endsWith("\r\n") || originalSnapshot.length === 0;
-    let result = joined;
-    if (origHadTrailing && !joined.endsWith("\n") && joined.length > 0)
-      result += "\n";
-    else if (!origHadTrailing && joined.endsWith("\n"))
-      result = result.slice(0, -1);
-    const newline = _TextUtils.DetectNewline(originalSnapshot);
-    return newline === "\n" ? result : result.replace(/\n/g, newline);
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/utils/arrayUtils.js
-var ArrayUtils = class {
-  /// <summary>
-  /// Groups items by key, preserving first-seen key order (like LINQ's GroupBy).
-  /// </summary>
-  static GroupBy(items, keySelector) {
-    const map = /* @__PURE__ */ new Map();
-    for (const item of items) {
-      const key = keySelector(item);
-      const arr = map.get(key) || [];
-      arr.push(item);
-      map.set(key, arr);
-    }
-    const result = [];
-    for (const [key, values] of map.entries())
-      result.push({ key, values });
-    return result;
-  }
-  /// <summary>
-  /// Returns a new array sorted ascending by key (stable, non-mutating, like LINQ's OrderBy).
-  /// </summary>
-  static OrderBy(items, keySelector) {
-    return [...items].sort((a, b) => {
-      const ka = keySelector(a), kb = keySelector(b);
-      return ka < kb ? -1 : ka > kb ? 1 : 0;
-    });
-  }
-  /// <summary>
-  /// Returns a new array sorted descending by key (stable, non-mutating, like LINQ's OrderByDescending).
-  /// </summary>
-  static OrderByDescending(items, keySelector) {
-    return [...items].sort((a, b) => {
-      const ka = keySelector(a), kb = keySelector(b);
-      return ka > kb ? -1 : ka < kb ? 1 : 0;
-    });
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/models.js
-var PatchInputFile = class {
-  Key;
-  InputFullText;
-  InputSelectedText;
-  constructor(Key, InputFullText = "", InputSelectedText = "") {
-    this.Key = Key;
-    this.InputFullText = InputFullText;
-    this.InputSelectedText = InputSelectedText;
-  }
-};
-var PatchOptions = class {
-  ContinueOnError;
-  MaxErrorIterations;
-  ContextWindowMax;
-  MaxChunksPerHunk;
-  SanitizeDiff;
-  Truncation;
-  ControlChars;
-  constructor(ContinueOnError = true, MaxErrorIterations = 10, ContextWindowMax = 8, MaxChunksPerHunk = 64, SanitizeDiff = true, Truncation = "warn", ControlChars = "error") {
-    this.ContinueOnError = ContinueOnError;
-    this.MaxErrorIterations = MaxErrorIterations;
-    this.ContextWindowMax = ContextWindowMax;
-    this.MaxChunksPerHunk = MaxChunksPerHunk;
-    this.SanitizeDiff = SanitizeDiff;
-    this.Truncation = Truncation;
-    this.ControlChars = ControlChars;
-  }
-};
-var PatchOutputFile = class {
-  Key;
-  Fuzz;
-  Edits;
-  InputSelectedText;
-  InputFullText;
-  OutputFullText;
-  Errors;
-  AlreadyAppliedCount;
-  Notices;
-  constructor(Key, Fuzz, Edits, InputSelectedText, InputFullText, OutputFullText, Errors, AlreadyAppliedCount = 0, Notices = []) {
-    this.Key = Key;
-    this.Fuzz = Fuzz;
-    this.Edits = Edits;
-    this.InputSelectedText = InputSelectedText;
-    this.InputFullText = InputFullText;
-    this.OutputFullText = OutputFullText;
-    this.Errors = Errors;
-    this.AlreadyAppliedCount = AlreadyAppliedCount;
-    this.Notices = Notices;
-  }
-};
-var PatchOutput = class {
-  Files;
-  constructor(Files) {
-    this.Files = Files;
-  }
-};
-var LineType;
-(function(LineType2) {
-  LineType2[LineType2["Context"] = 0] = "Context";
-  LineType2[LineType2["Delete"] = 1] = "Delete";
-  LineType2[LineType2["Insert"] = 2] = "Insert";
-})(LineType || (LineType = {}));
-var DiffLine = class {
-  Type;
-  Text;
-  CollapsedFrom;
-  constructor(Type2, Text, CollapsedFrom = null) {
-    this.Type = Type2;
-    this.Text = Text;
-    this.CollapsedFrom = CollapsedFrom;
-  }
-};
-var Hunk = class {
-  Key;
-  OldText;
-  NewText;
-  OldStart;
-  constructor(Key, OldText, NewText, OldStart = -1) {
-    this.Key = Key;
-    this.OldText = OldText;
-    this.NewText = NewText;
-    this.OldStart = OldStart;
-  }
-  Lines = [];
-  /// <summary>        
-  /// 1-based start position for the new side when available (from +c,d header), otherwise -1.
-  /// Unused, but here for Unified Diff completeness.
-  /// </summary>
-  NewStart = -1;
-  /// <summary>
-  /// 0-based line number in the original diff text where this hunk's body (first diff body line) starts.
-  /// -1 when unavailable (e.g., parser could not determine it).
-  /// </summary>
-  DiffBodyStartLine = -1;
-  // Set by the parser under TruncationPolicy 'warn' on the final hunk when it
-  // carried the tear signature.
-  TruncationSuspected = false;
-  // Set by the parser under ControlCharPolicy 'warn' when this hunk's insert
-  // lines carried raw control characters.
-  ControlCharsSuspected = false;
-  // Error-reporting stand-in Chunk for a hunk that was never anchored: its lines
-  // and diff location, no match.
-  ToUnanchoredChunk() {
-    return new Chunk([], this.Lines.filter((l) => l.Type == LineType.Delete).map((l) => l.Text), this.Lines.filter((l) => l.Type == LineType.Insert).map((l) => l.Text), [], UniqueMatch.NotFound, new DiffLocation(this));
-  }
-};
-var Edit = class _Edit {
-  LineIndex;
-  DeleteLines;
-  InsertLines;
-  Fuzz;
-  constructor(LineIndex, DeleteLines, InsertLines, Fuzz = 0) {
-    this.LineIndex = LineIndex;
-    this.DeleteLines = DeleteLines;
-    this.InsertLines = InsertLines;
-    this.Fuzz = Fuzz;
-  }
-  Shift(lineDelta) {
-    return new _Edit(this.LineIndex + lineDelta, this.DeleteLines, this.InsertLines, this.Fuzz);
-  }
-  ApplyTo(lines) {
-    if (this.LineIndex < 0 || this.LineIndex > lines.length)
-      return;
-    const deleteCount = Math.min(this.DeleteLines.length, lines.length - this.LineIndex);
-    if (deleteCount > 0)
-      lines.splice(this.LineIndex, deleteCount);
-    if (this.InsertLines.length > 0)
-      lines.splice(this.LineIndex, 0, ...this.InsertLines);
-  }
-};
-var DiffLocation = class {
-  StartLine;
-  Length;
-  constructor(startOrHunk, lengthOrStartLine, endLine) {
-    if (typeof startOrHunk === "number") {
-      this.StartLine = startOrHunk;
-      this.Length = lengthOrStartLine ?? 0;
-    } else {
-      const hunk = startOrHunk;
-      const startLine = lengthOrStartLine ?? 0;
-      const end = endLine ?? hunk.Lines.length - 1;
-      this.StartLine = hunk.DiffBodyStartLine + startLine + 1;
-      this.Length = end - startLine + 1;
-    }
-  }
-};
-var FileHunkGroup = class {
-  Key;
-  Hunks;
-  ContextOnlyHunkLines;
-  constructor(Key, Hunks, ContextOnlyHunkLines = []) {
-    this.Key = Key;
-    this.Hunks = Hunks;
-    this.ContextOnlyHunkLines = ContextOnlyHunkLines;
-  }
-};
-var Chunk = class _Chunk {
-  ContextBefore;
-  DeleteLines;
-  InsertLines;
-  ContextAfter;
-  Match;
-  DiffLocation;
-  constructor(ContextBefore, DeleteLines, InsertLines, ContextAfter, Match2, DiffLocation2) {
-    this.ContextBefore = ContextBefore;
-    this.DeleteLines = DeleteLines;
-    this.InsertLines = InsertLines;
-    this.ContextAfter = ContextAfter;
-    this.Match = Match2;
-    this.DiffLocation = DiffLocation2;
-  }
-  get IsPureInsert() {
-    return this.DeleteLines.length == 0 && this.InsertLines.length > 0;
-  }
-  get IsPureDelete() {
-    return this.DeleteLines.length > 0 && this.InsertLines.length == 0;
-  }
-  HasContextLines() {
-    return this.ContextBefore.length > 0 || this.ContextAfter.length > 0;
-  }
-  DeleteLinesWithContext() {
-    return [...this.ContextBefore, ...this.DeleteLines, ...this.ContextAfter];
-  }
-  InsertLinesWithContext() {
-    return [...this.ContextBefore, ...this.InsertLines, ...this.ContextAfter];
-  }
-  // The FULL context runs the diff supplied adjacent to this chunk's block, bounded
-  // by sibling blocks and hunk edges, in file order. A fact about the diff rather
-  // than the match — ContextBefore/After hold only the window the progressive-growth
-  // search consumed — so the dropped-context audit can see every supplied line, and
-  // `with` rewrites (fallback anchor, tiebreak, splice) carry the stamps forward.
-  SuppliedContextBefore = [];
-  SuppliedContextAfter = [];
-  with(values) {
-    const chunk = new _Chunk(values.ContextBefore ?? this.ContextBefore, values.DeleteLines ?? this.DeleteLines, values.InsertLines ?? this.InsertLines, values.ContextAfter ?? this.ContextAfter, values.Match ?? this.Match, values.DiffLocation ?? this.DiffLocation);
-    chunk.SuppliedContextBefore = values.SuppliedContextBefore ?? this.SuppliedContextBefore;
-    chunk.SuppliedContextAfter = values.SuppliedContextAfter ?? this.SuppliedContextAfter;
-    return chunk;
-  }
-};
-var MatchState;
-(function(MatchState2) {
-  MatchState2[MatchState2["Success"] = 0] = "Success";
-  MatchState2[MatchState2["Ambiguous"] = 1] = "Ambiguous";
-  MatchState2[MatchState2["NotFound"] = 2] = "NotFound";
-})(MatchState || (MatchState = {}));
-var UniqueMatch = class _UniqueMatch {
-  State;
-  LineIndex;
-  Fuzz;
-  constructor(State, LineIndex = -1, Fuzz = 0) {
-    this.State = State;
-    this.LineIndex = LineIndex;
-    this.Fuzz = Fuzz;
-  }
-  get IsAmbiguous() {
-    return this.State == MatchState.Ambiguous;
-  }
-  get IsNotFound() {
-    return this.State == MatchState.NotFound;
-  }
-  get IsSuccess() {
-    return this.State == MatchState.Success;
-  }
-  static get Ambiguous() {
-    return new _UniqueMatch(MatchState.Ambiguous);
-  }
-  static get NotFound() {
-    return new _UniqueMatch(MatchState.NotFound);
-  }
-  with(values) {
-    return new _UniqueMatch(values.State ?? this.State, values.LineIndex ?? this.LineIndex, values.Fuzz ?? this.Fuzz);
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/utils/yaml.js
-var Yaml = class _Yaml {
-  _sb = [];
-  // -------- Public API --------
-  AppendLine(text) {
-    this._sb.push(text + "\n");
-  }
-  Section(keyWithIndent) {
-    const [indent, key] = _Yaml.SplitIndentAndKey(keyWithIndent);
-    this._sb.push(`${indent}${key}:
-`);
-  }
-  Scalar(keyWithIndent, value) {
-    const [indent, key] = _Yaml.SplitIndentAndKey(keyWithIndent);
-    this._sb.push(`${indent}${key}: ${value}
-`);
-  }
-  Folded(keyWithIndent, value, contentIndent = 2, chompStrip = true) {
-    this.WriteBlockScalar(">", keyWithIndent, _Yaml.SplitLines(value), contentIndent, chompStrip);
-  }
-  Block(keyWithIndent, lines, contentIndent = 2, chompStrip = true) {
-    this.WriteBlockScalar("|", keyWithIndent, lines ?? [], contentIndent, chompStrip);
-  }
-  ToString() {
-    return this._sb.join("");
-  }
-  static SplitIndentAndKey(keyWithIndent) {
-    const leadingSpaces = TextUtils.CountLeadingWhitespace(keyWithIndent, " ");
-    const indentStr = " ".repeat(leadingSpaces);
-    const key = keyWithIndent.replace(/^\s+/, "");
-    return [indentStr, key];
-  }
-  static SplitLines(value) {
-    if (value == null || value.length == 0)
-      return [];
-    const lf = value.indexOf("\r") >= 0 ? value.replace(/\r\n/g, "\n").replace(/\r/g, "\n") : value;
-    return lf.split("\n");
-  }
-  WriteBlockScalar(style, keyWithIndent, lines, contentIndent, chompStrip) {
-    const [indent, key] = _Yaml.SplitIndentAndKey(keyWithIndent);
-    const chomp = chompStrip ? "-" : "+";
-    this._sb.push(`${indent}${key}: ${style}${contentIndent}${chomp}
-`);
-    const pad = " ".repeat(contentIndent);
-    let any = false;
-    for (const line of lines) {
-      any = true;
-      this._sb.push(`${indent}${pad}${line}
-`);
-    }
-    if (!any) {
-      this._sb.push(`${indent}${pad}
-`);
-    }
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/exceptions.js
-var PatchException = class extends Error {
-  Error;
-  constructor(error) {
-    super(error.SuggestedFixYaml);
-    this.Error = error;
-  }
-};
-var PatchParserException = class extends Error {
-  constructor(message) {
-    super(message ?? "Malformed diff patch");
-  }
-};
-var PatchError = class {
-  Type;
-  FailedMatch;
-  // The file key(s) the error concerns: the foreign key a FileMismatch named, or
-  // the comma-joined candidate keys of an ambiguous headerless routing; null otherwise.
-  FileKey;
-  // Diagnosis computed against the file at error time (e.g. the quoted line
-  // occurs inside one longer file line); null when no confident diagnosis.
-  Hint;
-  constructor(errorType, chunk, fileKey = null, hint = null) {
-    this.Type = errorType;
-    this.FailedMatch = chunk;
-    this.FileKey = fileKey;
-    this.Hint = hint;
-  }
-  toString() {
-    return `Failed to patch text with the diff provided.
-${this.SuggestedFixYaml}`;
-  }
-  get SuggestedFixYaml() {
-    const SummaryFor = (type) => ({
-      "MatchNotFound": "Matching lines not found; make sure the diff's context and deleted lines exactly match the original text.",
-      "MatchAmbiguous": "Matched multiple locations; make sure there are enough context lines to uniquely identify an edit.",
-      "ChunkDuplicated": "Duplicate chunks.",
-      "ChunkOverlapping": "Overlapping chunks.",
-      "FileMismatch": "The hunk's file header names a file that is not being patched, so it was not applied. Send hunks only for the file(s) being patched."
-    })[type] ?? "Patch failed.";
-    const diffLoc = this.FailedMatch.DiffLocation;
-    const y = new Yaml();
-    y.AppendLine("PatchError:");
-    y.Scalar("  Type", this.Type.toString());
-    if (this.FileKey != null)
-      y.Scalar("  File", this.FileKey);
-    y.Folded("  Summary", SummaryFor(this.Type));
-    if (this.Hint != null)
-      y.Folded("  Hint", this.Hint);
-    y.Section("  Details");
-    y.Section("    FailedMatch");
-    y.Block("      ContextBefore", this.FailedMatch.ContextBefore);
-    y.Block("      DeleteLines", this.FailedMatch.DeleteLines);
-    y.Block("      InsertLines", this.FailedMatch.InsertLines);
-    y.Block("      ContextAfter", this.FailedMatch.ContextAfter);
-    y.Section("      DiffLocation");
-    y.Scalar("        StartLine", diffLoc.StartLine.toString());
-    y.Scalar("        Length", diffLoc.Length.toString());
-    return y.ToString();
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/applier/guards.js
-var DuplicateGuard = class _DuplicateGuard {
-  // Two chunks that resolve to the same anchor with the same deletes and inserts are
-  // provably the same edit (an LLM re-emitting a hunk). Applying it once is
-  // unambiguously correct, so keep the first occurrence and drop the rest — the lenient
-  // move, with no false-positive risk: genuinely distinct edits differ in key
-  // (anchor or content) and fall through to OverlapGuard.
-  static Dedupe(args) {
-    const seen = /* @__PURE__ */ new Set();
-    const kept = [];
-    for (const chunk of args.Chunks) {
-      const key = _DuplicateGuard.BuildKey(chunk);
-      if (!seen.has(key)) {
-        seen.add(key);
-        kept.push(chunk);
-      }
-    }
-    return new InputChunks(args.InputFullText, kept, args.Options);
-  }
-  static BuildKey(c) {
-    let sb = "";
-    sb += `${c.Match?.LineIndex ?? -1}
-`;
-    for (const l of c.DeleteLines)
-      sb += `${l}
-`;
-    sb += `\u2192
-`;
-    for (const l of c.InsertLines)
-      sb += `${l}
-`;
-    return sb.toString();
-  }
-};
-var OverlapGuard = class {
-  static Guard(args) {
-    const chunks = ArrayUtils.OrderBy(args.Chunks, (c) => c.Match?.LineIndex ?? -1);
-    let currentEnd = 0;
-    for (const chunk of chunks) {
-      const idx = chunk.Match?.LineIndex ?? -1;
-      if (idx < 0)
-        continue;
-      if (idx < currentEnd)
-        throw new PatchException(new PatchError("ChunkOverlapping", chunk));
-      if (chunk.DeleteLines.length > 0)
-        currentEnd = idx + chunk.DeleteLines.length;
-    }
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/applier/editMinimizer.js
-var EditMinimizer = class _EditMinimizer {
-  static Same(a, b) {
-    return a === b;
-  }
-  /// <summary>
-  /// Convert an edit into a sequence of minimal edits, by excluding all unchanged lines.
-  /// </summary>
-  static *ToMinimalEdits(edit) {
-    const deleted = edit.DeleteLines;
-    const inserted = edit.InsertLines;
-    const maxLength = Math.max(deleted.length, inserted.length);
-    let diffStart = -1;
-    for (let i = 0; i <= maxLength; i++) {
-      const withinDeleted = i < deleted.length;
-      const withinInserted = i < inserted.length;
-      const atEnd = i == maxLength;
-      const isMatch = withinDeleted && withinInserted && _EditMinimizer.Same(deleted[i], inserted[i]);
-      const isDiff = !atEnd && (!withinDeleted || !withinInserted || !isMatch);
-      const isBoundary = atEnd || isMatch;
-      if (diffStart == -1 && isDiff) {
-        diffStart = i;
-      } else if (diffStart != -1 && isBoundary) {
-        const delCount = Math.max(0, Math.min(i, deleted.length) - diffStart);
-        const insCount = Math.max(0, Math.min(i, inserted.length) - diffStart);
-        const delBlock = delCount <= 0 ? [] : deleted.slice(diffStart, diffStart + delCount);
-        const insBlock = insCount <= 0 ? [] : inserted.slice(diffStart, diffStart + insCount);
-        yield new Edit(edit.LineIndex + diffStart, delBlock, insBlock, edit.Fuzz);
-        diffStart = -1;
-      }
-    }
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/applier/indenter.js
-var Anchor = class {
-  BaseIndent;
-  Shift;
-  constructor(BaseIndent, Shift) {
-    this.BaseIndent = BaseIndent;
-    this.Shift = Shift;
-  }
-};
-var Indenter = class _Indenter {
-  static DefaultTabSize = 4;
-  /// <summary>
-  /// Aligns an inserted block (<see cref="Chunk.InsertLines"/>) to the file’s
-  /// indent context at <see cref="Chunk.LineIndex"/>, leveraging
-  /// ContextBefore / ContextAfter when available.
-  /// </summary>
-  static AlignInsert(lines, chunk) {
-    const insert = chunk.InsertLines;
-    if (insert.length == 0)
-      return insert;
-    const tabSize = _Indenter.InferTabSize(lines.concat(insert));
-    const anchor = _Indenter.FindAnchor(lines, chunk.ContextBefore, chunk.Match.LineIndex - 1, true, tabSize) ?? _Indenter.FindAnchor(lines, chunk.ContextAfter, chunk.Match.LineIndex, false, tabSize) ?? new Anchor("", 0);
-    const reindented = new Set(chunk.DeleteLines.map((l) => _Indenter.SplitIndent(l)[1]));
-    const blankKeep = new Set(insert.filter((l) => !_Indenter.IsBlank(l)).map(_Indenter.LeadingWs).concat([anchor.BaseIndent]));
-    const tabStyle = anchor.BaseIndent.length > 0 ? anchor.BaseIndent.indexOf("	") >= 0 : lines.some((l) => l.startsWith("	"));
-    return insert.map((l) => _Indenter.Adjust(l, anchor, tabSize, tabStyle, reindented, blankKeep));
-  }
-  static FindAnchor(lines, contextLines, startIndex, backward, tabSize) {
-    if (contextLines.length == 0)
-      return null;
-    const [ctxWs, ctxTrim] = _Indenter.SplitIndent(contextLines[backward ? contextLines.length - 1 : 0]);
-    const ctxW = _Indenter.VisualWidth(ctxWs, tabSize);
-    const step = backward ? -1 : 1;
-    const end = backward ? -1 : lines.length;
-    for (let i = startIndex; i != end; i += step) {
-      const [ws, trim] = _Indenter.SplitIndent(lines[i]);
-      if (trim != ctxTrim)
-        continue;
-      return new Anchor(ws, _Indenter.VisualWidth(ws, tabSize) - ctxW);
-    }
-    return null;
-  }
-  static Adjust(line, anchor, tabSize, tabStyle, reindented, blankKeep) {
-    if (_Indenter.IsBlank(line))
-      return anchor.Shift == 0 && blankKeep.has(line) ? line : "";
-    const [ws, content] = _Indenter.SplitIndent(line);
-    const wsWidth = _Indenter.VisualWidth(ws, tabSize);
-    const target = Math.max(0, wsWidth + anchor.Shift);
-    if (wsWidth == target && (ws.indexOf("	") >= 0 == tabStyle || reindented.has(content)))
-      return ws + content;
-    return _Indenter.BuildIndent(anchor.BaseIndent, target, tabSize) + content;
-  }
-  static LeadingWs(line) {
-    return _Indenter.SplitIndent(line)[0];
-  }
-  static IsBlank(s) {
-    return s == null || s.length == 0 || Array.from(s).every((c) => c === " " || c === "	");
-  }
-  static SplitIndent(line) {
-    if (line == null || line.length == 0)
-      return ["", ""];
-    const i = TextUtils.CountLeadingWhitespace(line);
-    return [line.substring(0, i), line.substring(i)];
-  }
-  static InferTabSize(lines) {
-    for (const ws of Array.from(lines).map(_Indenter.LeadingWs)) {
-      const lastTab = ws.lastIndexOf("	");
-      if (lastTab >= 0) {
-        const spaces = ws.length - lastTab - 1;
-        if (spaces > 0)
-          return spaces;
-      }
-    }
-    return _Indenter.DefaultTabSize;
-  }
-  static VisualWidth(indent, tabSize) {
-    return Array.from(indent).map((c) => c == "	" ? tabSize : 1).reduce((a, b) => a + b, 0);
-  }
-  static BuildIndent(baseIndent, targetW, tabSize) {
-    if (targetW <= 0)
-      return "";
-    const baseW = _Indenter.VisualWidth(baseIndent, tabSize);
-    const delta = targetW - baseW;
-    if (delta == 0)
-      return baseIndent;
-    if (delta > 0)
-      return baseIndent + " ".repeat(delta);
-    return baseIndent.indexOf("	") >= 0 ? "	".repeat(Math.floor(targetW / tabSize)) + " ".repeat(targetW % tabSize) : " ".repeat(targetW);
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/applier/matchHint.js
-var MatchHint = class _MatchHint {
-  // A quoted line inside exactly one longer file line is the prose line-model
-  // mistake: the author's "line" (a sentence of an unwrapped paragraph, or a
-  // re-flowed hard wrap) is a slice of the file's physical line. Matching stays
-  // refused — a head fragment is byte-identical to an elided whole-line delete,
-  // so either auto-reading risks silent corruption — but naming the line is
-  // correct under both readings: the retry re-quotes it whole.
-  static SubLine(chunk, lines) {
-    for (const q of chunk.DeleteLinesWithContext()) {
-      if (q.trim().length < _MatchHint.MinHintLineContent)
-        continue;
-      if (lines.includes(q))
-        continue;
-      const containing = [];
-      for (let i = 0; i < lines.length && containing.length < 2; i++)
-        if (lines[i].length > q.length && lines[i].includes(q))
-          containing.push(i);
-      if (containing.length != 1)
-        continue;
-      return `The diff line "${_MatchHint.Preview(q)}" matches only PART of line ${containing[0] + 1}, which is ${lines[containing[0]].length} characters long \u2014 in prose, a whole paragraph is often one physical line. Re-send the diff quoting entire lines exactly.`;
-    }
-    return null;
-  }
-  static Preview(s) {
-    const t = s.trim();
-    return t.length <= 60 ? t : t.slice(0, 57) + "...";
-  }
-  // Trimmed length a quoted line must reach before containment counts as
-  // evidence: short strings occur inside longer lines by coincidence.
-  static MinHintLineContent = 12;
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/applier/chunkApplier.js
-var InputChunks = class {
-  InputFullText;
-  Chunks;
-  Options;
-  constructor(InputFullText, Chunks, Options) {
-    this.InputFullText = InputFullText;
-    this.Chunks = Chunks;
-    this.Options = Options;
-  }
-};
-var OutputEdits = class {
-  OutputText;
-  Edits;
-  Errors;
-  constructor(OutputText, Edits, Errors) {
-    this.OutputText = OutputText;
-    this.Edits = Edits;
-    this.Errors = Errors;
-  }
-};
-var ChunkApplier = class _ChunkApplier {
-  // NOTE: on partial failure, Apply is all-or-nothing — it returns the ORIGINAL
-  // text untouched alongside the errors, never a best-effort partial application.
-  static Apply(targetText, chunks, options) {
-    const inputChunks = new InputChunks(targetText, chunks, options);
-    if (!options.ContinueOnError)
-      return _ChunkApplier.ApplyChunks(inputChunks);
-    const errors = [];
-    for (let attempt = 0; attempt < options.MaxErrorIterations; attempt++) {
-      try {
-        const r = _ChunkApplier.ApplyChunks(inputChunks);
-        if (errors.length)
-          return new OutputEdits(targetText, [], errors);
-        return r;
-      } catch (ex) {
-        if (ex instanceof PatchException) {
-          errors.push(ex.Error);
-          const idx = chunks.indexOf(ex.Error.FailedMatch);
-          if (idx >= 0)
-            chunks.splice(idx, 1);
-        } else
-          throw ex;
-      }
-    }
-    return new OutputEdits(targetText, [], errors);
-  }
-  static ApplyChunks(args) {
-    args = DuplicateGuard.Dedupe(args);
-    OverlapGuard.Guard(args);
-    const lines = TextUtils.ToLines(args.InputFullText);
-    const edits = args.Chunks.map((chunk) => _ChunkApplier.CreateEdit(chunk, lines));
-    const workingLines = Array.from(lines);
-    for (const edit of ArrayUtils.OrderByDescending(edits, (e) => e.LineIndex))
-      edit.ApplyTo(workingLines);
-    const patched = TextUtils.RoundTripWhitespace(args.InputFullText, workingLines);
-    const minimalEdits = edits.flatMap((e) => Array.from(EditMinimizer.ToMinimalEdits(e)));
-    return new OutputEdits(patched, minimalEdits, []);
-  }
-  static CreateEdit(chunk, lines) {
-    const match = chunk.Match;
-    if (match.IsAmbiguous)
-      throw new PatchException(new PatchError("MatchAmbiguous", chunk));
-    if (match.IsNotFound)
-      throw new PatchException(new PatchError("MatchNotFound", chunk, null, MatchHint.SubLine(chunk, lines)));
-    return new Edit(match.LineIndex, Array.from(chunk.DeleteLines), Indenter.AlignInsert(lines, chunk), match.Fuzz);
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/heuristics.js
-var DiffContentHeuristics = class _DiffContentHeuristics {
-  /**
-   * Checks if a line starts with a doubled marker (++ or --)
-   */
-  static IsDoubleMarker(line) {
-    return line.length > 1 && line[0] == line[1] && (line[0] == "-" || line[0] == "+");
-  }
-  /**
-   * Determines if a doubled marker represents content rather than diff syntax.
-   *
-   * Examples:
-   * - `--bg-color` → true (CSS variable, content)
-   * - `--` → true (exactly two hyphens, content)
-   * - `-- text` → false (deletion of markdown list `- text`, diff syntax)
-   * - `---comment` → false (deletion of `--comment`, diff syntax)
-   * - `----` → false (deletion of `--`, diff syntax)
-   * - `++var` → true (C++ code, content)
-   * - `++ text` → false (insertion of `+ text`, diff syntax)
-   * - `+++` → false (insertion of `+`, diff syntax)
-   */
-  static IsDoubleMarkerContent(line) {
-    if (!_DiffContentHeuristics.IsDoubleMarker(line))
-      return false;
-    if (line.length == 2)
-      return true;
-    return line[2] != line[0] && line[2] != " ";
-  }
-  /**
-   * A '++X' line that is a candidate for the sloppy doubled-insert-marker
-   * collapse ('++X' → insert 'X'). Tripled markers are proper syntax
-   * ('+++X' = insert '++X') and never candidates.
-   */
-  static IsSloppyDoublePlus(line) {
-    return line.length > 1 && line[0] == "+" && line[1] == "+" && (line.length == 2 || line[2] != "+");
-  }
-  /**
-   * True when the hunk body proves the edit region is itself diff-shaped:
-   * a context or deletion line whose CONTENT starts with '+' or '-' exists
-   * verbatim in the file. In such a region, doubled markers are diff syntax
-   * over diff-shaped content, not sloppy doubling.
-   */
-  static IsDiffShapedRegion(rawLines, fileLines) {
-    if (!fileLines || fileLines.length == 0)
-      return false;
-    for (const l of rawLines) {
-      if (l.length < 2 || l[0] != " " && l[0] != "-")
-        continue;
-      if (l[1] != "+" && l[1] != "-")
-        continue;
-      const content = l.substring(1);
-      if (fileLines.some((f) => f == content))
-        return true;
-    }
-    return false;
-  }
-  /**
-   * Validates whether a line (after stripping indentation) represents valid diff syntax.
-   * Used by StripIndent to determine if indentation should be removed.
-   *
-   * Returns false for content that looks like diff markers:
-   * - `--text` (CSS variables)
-   * - `-abc-*` (hyphenated identifiers like -webkit-*)
-   */
-  static IsValidDiffLineStart(line) {
-    if (line.length == 0)
-      return false;
-    const first = line[0];
-    if (first == " " || first == "+")
-      return true;
-    if (first == "-") {
-      if (line.length == 1)
-        return true;
-      if (line[1] == "-")
-        return line.length > 2 && line[2] == "-";
-      if (_DiffContentHeuristics.IsHyphenatedIdentifier(line))
-        return false;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Pattern: -[a-z]+-  (e.g., -webkit-*, -moz-*)
-   * If hyphen is followed by letters then another hyphen, it's structural content.
-   */
-  static IsHyphenatedIdentifier(line) {
-    if (line.length < 3 || line[0] != "-")
-      return false;
-    let i = 1;
-    while (i < line.length && line[i] >= "a" && line[i] <= "z")
-      i++;
-    return i > 1 && i < line.length && line[i] == "-";
-  }
-  /**
-   * Applies heuristics to classify raw lines (lines without explicit diff markers).
-   *
-   * Heuristic: Raw lines are treated as context until we've seen explicit context markers.
-   * Once explicit context has been seen, a raw line followed by an insertion before a
-   * context/deletion boundary is treated as a deletion.
-   *
-   * This helps handle sloppy diffs where deletion markers are omitted but can be inferred.
-   */
-  static ApplyRawLineHeuristic(raw, rawLines, index, seenExplicitContext, fileLines) {
-    const insAhead = _DiffContentHeuristics.HasInsertionAheadBeforeContextOrDeletion(rawLines, index);
-    if (insAhead && seenExplicitContext) {
-      return new DiffLine(LineType.Delete, _DiffContentHeuristics.StripInlineComment(raw, fileLines));
-    }
-    if (insAhead) {
-      const verified = _DiffContentHeuristics.TryVerifiedCommentStrip(raw, fileLines);
-      if (verified !== null)
-        return new DiffLine(LineType.Delete, verified);
-    }
-    return new DiffLine(LineType.Context, raw);
-  }
-  static InlineCommentMarkers = [" //", " --", " #"];
-  /**
-   * Returns the comment-stripped form of a line when file content verifies it:
-   * the full line must NOT exist in the file and the stripped variant MUST — so
-   * real content containing " --" (SQL) or " #" (Python) is never mangled.
-   * Returns null when no verified strip exists.
-   */
-  static TryVerifiedCommentStrip(input, fileLines) {
-    if (!fileLines || fileLines.length == 0)
-      return null;
-    if (fileLines.some((l) => l === input))
-      return null;
-    for (const marker of _DiffContentHeuristics.InlineCommentMarkers) {
-      for (let idx = input.indexOf(marker); idx >= 0; idx = input.indexOf(marker, idx + 1)) {
-        const candidate = input.substring(0, idx).trimEnd();
-        if (fileLines.some((l) => l === candidate))
-          return candidate;
-      }
-    }
-    return null;
-  }
-  /**
-   * Strips an inline comment the LLM appended to an inferred deletion line
-   * (e.g., "Line2  // Missing - marker" → "Line2").
-   * Prefers a content-verified strip; without file content (or when
-   * verification is inconclusive), falls back to stripping C-style " //" only.
-   */
-  static StripInlineComment(input, fileLines) {
-    if (fileLines?.some((l) => l === input))
-      return input;
-    const verified = _DiffContentHeuristics.TryVerifiedCommentStrip(input, fileLines);
-    if (verified !== null)
-      return verified;
-    const idx = input.indexOf(" //");
-    return idx >= 0 ? input.substring(0, idx) : input;
-  }
-  /**
-   * Checks if there's an insertion (line starting with '+') ahead of the current position,
-   * before encountering a context line, deletion line, or blank line (boundaries).
-   *
-   * Used to infer whether a raw line should be treated as a deletion.
-   */
-  static HasInsertionAheadBeforeContextOrDeletion(rawLines, currentIndex) {
-    for (let i = currentIndex + 1; i < rawLines.length; i++) {
-      const l = rawLines[i];
-      if (l.length == 0)
-        break;
-      const c = l[0];
-      if (c == " ")
-        break;
-      if (c == "-" && !_DiffContentHeuristics.IsDoubleMarkerContent(l))
-        break;
-      if (c == "+")
-        return true;
-    }
-    return false;
-  }
-  /**
-   * Checks if a line starting with "-" or "+" is likely content with a missing context prefix.
-   * Uses file content to disambiguate: if file has the line but NOT the would-be-modified content.
-   *
-   * Examples:
-   * - "- list item" might be markdown bullet, not deletion of " list item"
-   * - "+ Add feature" might be changelog entry, not insertion of " Add feature"
-   *
-   * @returns true if line should be treated as context, false if it should be treated as diff operation
-   */
-  static IsMissingContextPrefix(line, fileLines) {
-    if (line.length < 2)
-      return false;
-    const marker = line[0];
-    if (marker !== "-" && marker !== "+")
-      return false;
-    if (marker === "+" && line[1] !== " ")
-      return false;
-    const hasContentMatch = fileLines.some((l) => l === line);
-    const hasOperationMatch = fileLines.some((l) => l === line.substring(1));
-    return hasContentMatch && !hasOperationMatch;
-  }
-  /**
-   * Resolves ambiguity when stripping indentation reveals "- " (hyphen + space).
-   *
-   * This pattern is ambiguous:
-   * - Could be an indented DELETE line (deleting content starting with a space)
-   * - Could be a properly formatted CONTEXT line containing a markdown bullet
-   *
-   * Example: "    - Label them..." could mean:
-   * - DELETE: Remove line " Label them..." (space + content) from file
-   * - CONTEXT: Keep line "   - Label them..." (3 spaces + bullet) in file
-   *
-   * Resolution: Check which interpretation matches the actual file content.
-   * If only one matches, use that. If both or neither, prefer CONTEXT (conservative).
-   *
-   * @param original - The original line before stripping (e.g., "    - Label them...")
-   * @param stripped - The line after stripping indentation (e.g., "- Label them...")
-   * @param fileLines - Lines from the actual file being patched
-   * @returns The line to use (original if CONTEXT, stripped if DELETE)
-   */
-  static ResolveHyphenSpaceAmbiguity(original, stripped, fileLines) {
-    const contextContent = original.length > 0 && original[0] === " " ? original.substring(1) : original;
-    const deleteContent = stripped.substring(1);
-    const hasContextMatch = fileLines.some((line) => line === contextContent);
-    const hasDeleteMatch = fileLines.some((line) => line === deleteContent);
-    if (hasContextMatch && !hasDeleteMatch)
-      return original;
-    if (hasDeleteMatch && !hasContextMatch)
-      return stripped;
-    return original;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/hunkBuilder.js
-var Header = class _Header {
-  Path;
-  OldStart;
-  OldCount;
-  NewStart;
-  NewCount;
-  DiffBodyStartLine;
-  constructor(Path = null, OldStart = -1, OldCount = 0, NewStart = -1, NewCount = 0, DiffBodyStartLine = -1) {
-    this.Path = Path;
-    this.OldStart = OldStart;
-    this.OldCount = OldCount;
-    this.NewStart = NewStart;
-    this.NewCount = NewCount;
-    this.DiffBodyStartLine = DiffBodyStartLine;
-  }
-  static WithParsed(h, parsedHdr, diffBodyStartLine) {
-    return new _Header(h.Path, parsedHdr.OldStart, parsedHdr.OldCount, parsedHdr.NewStart, parsedHdr.NewCount, diffBodyStartLine);
-  }
-  static ParseSide(header, part, prefix, isOld) {
-    if (!part.startsWith(prefix))
-      return header;
-    const split = part.substring(1).split(",");
-    const start = split.length > 0 && !isNaN(parseInt(split[0])) ? parseInt(split[0]) : -1;
-    const count = split.length > 1 && !isNaN(parseInt(split[1])) ? parseInt(split[1]) : 1;
-    return isOld ? new _Header(header.Path, start, count, header.NewStart, header.NewCount, header.DiffBodyStartLine) : new _Header(header.Path, header.OldStart, header.OldCount, start, count, header.DiffBodyStartLine);
-  }
-};
-var HunkBuilder = class _HunkBuilder {
-  hunks = [];
-  bodySeen = /* @__PURE__ */ new Map();
-  get Hunks() {
-    return this.hunks;
-  }
-  // Only the diff's FINAL hunk can be torn by a cutoff, so the parser reads this
-  // once, after the last commit; mid-diff the same signature is just sloppy counting.
-  LastHunkTruncated = false;
-  // A closing ``` fence is completion evidence a token cutoff cannot emit — the
-  // tear signature on a fence-closed hunk is miscount slop, not truncation.
-  // (Trailing prose already clears the flag via the pure-context commit path.)
-  ClearTruncation() {
-    this.LastHunkTruncated = false;
-  }
-  // Diff line of the first @@-headed body with real content but no change lines.
-  // Such a hunk can never be intentional (its '+'/'-' markers were lost, and the
-  // loss is ambiguous — adds or deletes?), so the parser rejects the whole diff
-  // instead of silently dropping it. Bodies outside any hunk (prose before or
-  // after a diff) and blank-only bodies keep flowing through silently.
-  // Diff line of each @@-headed body that had real content but no change lines. Such a
-  // hunk states no change, so it is skipped and its siblings apply — but the lines are
-  // surfaced so the caller can name the skip rather than report a clean success. Bodies
-  // outside any hunk (prose before or after a diff) and blank-only bodies are not hunks
-  // at all and are never recorded.
-  ContextOnlyHunkLines = [];
-  CommitIfAny(hdr, body, fileLines) {
-    if (body.length == 0)
-      return;
-    const blankContextDeletion = _HunkBuilder.IsBlankContextDeletion(hdr.OldCount, hdr.NewCount, body);
-    if (!blankContextDeletion && !body.some((l) => l.length > 0 && (l[0] == "-" || l[0] == "+"))) {
-      this.LastHunkTruncated = false;
-      if (hdr.DiffBodyStartLine >= 0 && body.some((l) => l.trim().length > 0))
-        this.ContextOnlyHunkLines.push(hdr.DiffBodyStartLine);
-      body.length = 0;
-      return;
-    }
-    const diffLines = _HunkBuilder.BuildLines(body, blankContextDeletion, fileLines);
-    this.LastHunkTruncated = _HunkBuilder.IsTruncated(hdr, diffLines);
-    const oldSb = [];
-    const newSb = [];
-    let oldLines = 0, newLines = 0;
-    for (const dl of diffLines) {
-      switch (dl.Type) {
-        case LineType.Insert:
-          newSb.push(dl.Text, "\n");
-          newLines++;
-          break;
-        case LineType.Delete:
-          oldSb.push(dl.Text, "\n");
-          oldLines++;
-          break;
-        case LineType.Context:
-          oldSb.push(dl.Text, "\n");
-          oldLines++;
-          newSb.push(dl.Text, "\n");
-          newLines++;
-          break;
-      }
-    }
-    const oldTxt = oldLines > 0 ? oldSb.join("") : "";
-    const newTxt = newLines > 0 ? newSb.join("") : "";
-    if (oldTxt == newTxt) {
-      body.length = 0;
-      return;
-    }
-    const hunk = new Hunk(hdr.Path ?? "", oldTxt, newTxt, hdr.OldStart);
-    hunk.NewStart = hdr.NewStart;
-    hunk.Lines = diffLines;
-    hunk.DiffBodyStartLine = hdr.DiffBodyStartLine;
-    this.AddHunk(hunk);
-    body.length = 0;
-  }
-  // Token-limit cutoff: body ends mid-change-run and the header declares more lines
-  // than delivered, asymmetrically. Symmetric deficits are stripped context (the
-  // anchorer recovers) and never count. An insert-ending body is torn only when the
-  // old side is ALSO short (promised trailing context never arrived): an old side
-  // fully delivered is complete by its own header, and a new-side deficit alone is
-  // overcount slop that must still apply — a complete append with a miscounted
-  // header is indistinguishable from a mid-run cut, and counts are tie-breakers,
-  // never sole grounds for rejection. A delete-ending body is the mirror: torn only
-  // when the NEW side is also short (newDeficit > 0) AND the old side is shorter
-  // still (the delete run was cut), so an over-counted-but-complete delete hunk
-  // (newDeficit == 0) applies as overcount slop. Cost (both branches): a cut with no
-  // trailing context owed on the completed side goes undetected.
-  static IsTruncated(hdr, lines) {
-    if (hdr.OldStart < 0 || hdr.NewStart < 0 || lines.length == 0)
-      return false;
-    const last = lines[lines.length - 1].Type;
-    if (last == LineType.Context)
-      return false;
-    const actualOld = lines.filter((l) => l.Type != LineType.Insert).length;
-    const actualNew = lines.filter((l) => l.Type != LineType.Delete).length;
-    const oldDeficit = hdr.OldCount - actualOld, newDeficit = hdr.NewCount - actualNew;
-    return last == LineType.Insert ? oldDeficit > 0 && newDeficit > oldDeficit : newDeficit > 0 && oldDeficit > newDeficit;
-  }
-  // Identical bodies collapse when the repeat adds no placement info (bare @@ or a
-  // start line already seen) — LLM-slop duplication. But git legitimately emits
-  // byte-identical hunks at distinct line numbers when a file repeats a pattern;
-  // those are separate edits, and the anchorer's line-number tiebreak places each
-  // at its own site. Distinct bodies always survive.
-  AddHunk(h) {
-    const bodyKey = `${h.OldText}
-\u241E
-${h.NewText}`;
-    const starts = this.bodySeen.get(bodyKey);
-    if (starts) {
-      if (h.OldStart < 0 || starts.has(-1) || starts.has(h.OldStart))
-        return;
-      starts.add(h.OldStart);
-    } else {
-      this.bodySeen.set(bodyKey, /* @__PURE__ */ new Set([h.OldStart]));
-    }
-    this.hunks.push(h);
-  }
-  static BuildLines(rawLines, blankContextDeletion, fileLines) {
-    const result = [];
-    let seenExplicitContext = false;
-    const diffShaped = DiffContentHeuristics.IsDiffShapedRegion(rawLines, fileLines);
-    for (let i = 0; i < rawLines.length; i++) {
-      const raw = rawLines[i];
-      if (raw.length == 0) {
-        if (i == rawLines.length - 1)
-          continue;
-        result.push(new DiffLine(blankContextDeletion ? LineType.Delete : LineType.Context, ""));
-        continue;
-      }
-      if (blankContextDeletion) {
-        const c = raw[0];
-        result.push(new DiffLine(LineType.Delete, c == " " || c == "-" ? _HunkBuilder.RemoveDiffPrefix(raw) : raw));
-        continue;
-      }
-      switch (raw[0]) {
-        case "+":
-        case "-":
-          if (fileLines && DiffContentHeuristics.IsMissingContextPrefix(raw, fileLines)) {
-            result.push(new DiffLine(LineType.Context, raw));
-            seenExplicitContext = true;
-            break;
-          }
-          if (raw[0] === "+") {
-            if (DiffContentHeuristics.IsSloppyDoublePlus(raw)) {
-              result.push(diffShaped ? new DiffLine(LineType.Insert, raw.substring(1)) : new DiffLine(LineType.Insert, _HunkBuilder.RemoveDiffPrefix(raw), raw));
-              break;
-            }
-            result.push(new DiffLine(LineType.Insert, _HunkBuilder.RemoveDiffPrefix(raw)));
-            break;
-          }
-          if (DiffContentHeuristics.IsDoubleMarkerContent(raw)) {
-            if (fileLines && fileLines.some((l) => l == raw.substring(1)) && !fileLines.some((l) => l == raw)) {
-              result.push(new DiffLine(LineType.Delete, raw.substring(1)));
-              break;
-            }
-            if (seenExplicitContext && raw.length > 2 && raw[2] === " ") {
-              result.push(new DiffLine(LineType.Delete, raw.substring(1)));
-            } else {
-              result.push(DiffContentHeuristics.ApplyRawLineHeuristic(raw, rawLines, i, seenExplicitContext, fileLines));
-            }
-          } else {
-            result.push(new DiffLine(LineType.Delete, _HunkBuilder.RemoveDiffPrefix(raw)));
-          }
-          break;
-        case " ":
-          result.push(new DiffLine(LineType.Context, _HunkBuilder.RemoveDiffPrefix(raw)));
-          seenExplicitContext = true;
-          break;
-        default:
-          result.push(DiffContentHeuristics.ApplyRawLineHeuristic(raw, rawLines, i, seenExplicitContext, fileLines));
-          break;
-      }
-    }
-    return result;
-  }
-  static IsBlankContextDeletion(oldCount, newCount, rawLines) {
-    return oldCount > 0 && newCount == 0 && rawLines.every((l) => l.length == 0 || l[0] == " ");
-  }
-  // Strip diff prefix: ` foo` → `foo`, `-bar` → `bar`, `+baz` → `baz`
-  // Sloppy doubled markers: `++code` → `code`, `++ code` → `code`
-  // But NOT tripled: `---comment` → `--comment` (proper syntax for deleting `--comment`)
-  // And NOT `-- text` which is deletion of `- text` (markdown list), not sloppy
-  static RemoveDiffPrefix(s) {
-    if (!s || s.length <= 1)
-      return "";
-    let result = s.substring(1);
-    if (DiffContentHeuristics.IsSloppyDoublePlus(s)) {
-      result = result.substring(1);
-      if (result[0] === " " || result[0] === "	")
-        result = result.substring(1);
-    }
-    return result;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/unifiedDiffParser.js
-var UnifiedDiffParser = class _UnifiedDiffParser {
-  /**
-   * Parse a unified diff into structured hunks.
-   * @param diff - The diff text to parse
-   * @param files - Map of filename to content (content used for disambiguation of ambiguous lines)
-   * @param truncation - Verdict for a surviving tear signature on the final hunk
-   * @param controlChars - Verdict for raw control characters in insert lines
-   */
-  static Parse(diff, files, truncation = "warn", controlChars = "error") {
-    const parsed = diff == null || diff.trim().length == 0 ? { Hunks: [], ContextOnlyLines: [] } : _UnifiedDiffParser.ParseHunks(diff, files, truncation, controlChars);
-    const hunks = parsed.Hunks;
-    const ctxOnly = parsed.ContextOnlyLines;
-    const fileKeySet = new Set(files.keys());
-    const headerless = hunks.filter((h) => h.Key == null || h.Key == "");
-    const explicitKnown = hunks.filter((h) => h.Key != null && h.Key != "" && fileKeySet.has(h.Key));
-    const explicitFallback = hunks.filter((h) => h.Key != null && h.Key != "" && !fileKeySet.has(h.Key));
-    const groups = [];
-    if (headerless.length > 0)
-      groups.push(new FileHunkGroup("", headerless, ctxOnly));
-    if (explicitKnown.length > 0)
-      ArrayUtils.GroupBy(explicitKnown, (h) => h.Key).map((g) => new FileHunkGroup(g.key, g.values, ctxOnly)).forEach((x) => groups.push(x));
-    const treatAsSingleFile = fileKeySet.size == 1 && fileKeySet.has("") && explicitKnown.length == 0 && headerless.length == 0 && Array.from(new Set(explicitFallback.map((h) => h.Key))).length == 1;
-    if (treatAsSingleFile && explicitFallback.length > 0)
-      groups.push(new FileHunkGroup("", explicitFallback, ctxOnly));
-    else if (explicitFallback.length > 0)
-      ArrayUtils.GroupBy(explicitFallback, (h) => h.Key).map((g) => new FileHunkGroup(g.key, g.values, ctxOnly)).forEach((x) => groups.push(x));
-    if (groups.length == 0 && ctxOnly.length > 0)
-      groups.push(new FileHunkGroup("", [], ctxOnly));
-    return groups;
-  }
-  static ParseHunks(diff, fileContents, truncation = "warn", controlChars = "error") {
-    const hunkBuilder = new HunkBuilder();
-    const body = [];
-    let header = new Header();
-    let inFence = false;
-    let inHunkBody = false;
-    let lineNo = -1;
-    const defaultFileLines = fileContents?.size == 1 && fileContents.has("") ? _UnifiedDiffParser.ToFileLines(fileContents.get("")) : void 0;
-    let currentFileLines = defaultFileLines;
-    let fileLineSet = _UnifiedDiffParser.ToLineSet(currentFileLines);
-    for (const raw of _UnifiedDiffParser.StripCommonIndent(diff.replace(/\r\n/g, "\n")).split("\n")) {
-      lineNo++;
-      if (raw.length > 1 && raw[0] == " " && fileLineSet != null && fileLineSet.has(raw.slice(1).replace(/\s+$/, ""))) {
-        body.push(raw);
-        continue;
-      }
-      const line = _UnifiedDiffParser.StripIndent(raw, currentFileLines);
-      if (line.startsWith("```diff")) {
-        inFence = true;
-        continue;
-      }
-      if (!inFence && line.startsWith("```")) {
-        continue;
-      }
-      if (inFence && line.startsWith("```")) {
-        hunkBuilder.CommitIfAny(header, body, currentFileLines);
-        hunkBuilder.ClearTruncation();
-        header.DiffBodyStartLine = -1;
-        inFence = false;
-        inHunkBody = false;
-        continue;
-      }
-      if (_UnifiedDiffParser.IsMeta(line))
-        continue;
-      const path = _UnifiedDiffParser.TryParseFileHeader(line);
-      if (path && _UnifiedDiffParser.IsFileHeader(line, path, inHunkBody, fileContents, fileLineSet, body, currentFileLines)) {
-        hunkBuilder.CommitIfAny(header, body, currentFileLines);
-        header = new Header(path);
-        currentFileLines = _UnifiedDiffParser.ToFileLines(fileContents?.get(path)) ?? defaultFileLines;
-        fileLineSet = _UnifiedDiffParser.ToLineSet(currentFileLines);
-        inHunkBody = false;
-        continue;
-      }
-      const parsedHdr = _UnifiedDiffParser.TryParseHunkHeader(line);
-      if (parsedHdr) {
-        hunkBuilder.CommitIfAny(header, body, currentFileLines);
-        header = Header.WithParsed(header, parsedHdr, lineNo + 1);
-        inHunkBody = true;
-        continue;
-      }
-      body.push(line);
-    }
-    hunkBuilder.CommitIfAny(header, body, currentFileLines);
-    const hunks = hunkBuilder.Hunks;
-    if (hunkBuilder.LastHunkTruncated && truncation != "ignore") {
-      if (truncation == "error")
-        throw new PatchParserException("The diff appears truncated mid-hunk: the final hunk's header declares more lines than its body delivers. Nothing was applied; re-send the complete diff.");
-      if (hunks.length > 0)
-        hunks[hunks.length - 1].TruncationSuspected = true;
-    }
-    if (controlChars != "ignore") {
-      for (const hunk of hunks) {
-        const suspect = _UnifiedDiffParser.DescribeControlChars(hunk.Lines.filter((l) => l.Type == LineType.Insert).map((l) => l.Text));
-        if (suspect == null)
-          continue;
-        if (controlChars == "error")
-          throw new PatchParserException(`Insert lines contain raw control characters (${suspect}) \u2014 almost certainly transport damage, not intended content. Nothing was applied; re-send the diff with the intended text (or opt into the 'warn'/'ignore' policy).`);
-        hunk.ControlCharsSuspected = true;
-      }
-    }
-    return { Hunks: hunks, ContextOnlyLines: hunkBuilder.ContextOnlyHunkLines };
-  }
-  static IsSuspectControlChar(c) {
-    const cp = c.charCodeAt(0);
-    return cp < 32 && c != "	" && c != "\n" && c != "\r" && c != "\f" || cp == 127;
-  }
-  // "U+0000 x2, U+001B x1" — names the invisible damage so the caller can see it.
-  static DescribeControlChars(lines) {
-    const counts = /* @__PURE__ */ new Map();
-    for (const line of lines)
-      for (const c of line)
-        if (_UnifiedDiffParser.IsSuspectControlChar(c))
-          counts.set(c, (counts.get(c) ?? 0) + 1);
-    if (counts.size == 0)
-      return null;
-    return [...counts.entries()].sort((a, b) => a[0].charCodeAt(0) - b[0].charCodeAt(0)).map(([c, n]) => `U+${c.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")} x${n}`).join(", ");
-  }
-  static MetaPrefixes = [
-    "index ",
-    "new file mode ",
-    "deleted file mode ",
-    "similarity index ",
-    "rename from ",
-    "rename to ",
-    "Binary files ",
-    "GIT binary patch",
-    "mode change "
-  ];
-  static IsMeta(line) {
-    return _UnifiedDiffParser.MetaPrefixes.some((p) => line.startsWith(p));
-  }
-  static ToFileLines(content) {
-    return content ? content.replace(/\r\n/g, "\n").split("\n") : void 0;
-  }
-  static ToLineSet(lines) {
-    return lines ? new Set(lines.map((l) => l.replace(/\s+$/, ""))) : void 0;
-  }
-  // Strips the longest common whitespace prefix from all non-empty diff body lines.
-  // This normalizes diffs that are uniformly indented (e.g. pasted inside a markdown block
-  // or another indented structure), while preserving the single-space context markers on
-  // lines whose content happens to start with '+' or '-'.
-  //
-  // @@ hunk headers are excluded from the prefix calculation because an LLM may indent
-  // body lines but not the header (or vice versa). The strip is applied only to lines
-  // that actually start with the computed prefix, so unindented headers are left intact.
-  //
-  // Runs before the per-line StripIndent pass: this handles uniform indentation
-  // (including a single-space indent that per-line stripping must not touch), while
-  // StripIndent handles ragged 2+ whitespace indentation line by line.
-  static StripCommonIndent(diff) {
-    const lines = diff.split("\n");
-    let common = null;
-    for (const line of lines) {
-      if (line.length == 0)
-        continue;
-      const i = TextUtils.CountLeadingWhitespace(line);
-      if (line.startsWith("@@", i))
-        continue;
-      const prefix = line.substring(0, i);
-      if (common == null) {
-        common = prefix;
-        continue;
-      }
-      const minLen = Math.min(common.length, prefix.length);
-      let j = 0;
-      while (j < minLen && common[j] == prefix[j])
-        j++;
-      common = common.substring(0, j);
-      if (common.length == 0)
-        return diff;
-    }
-    if (common == null || common.length == 0)
-      return diff;
-    const c = common;
-    if (!lines.some((l) => l.startsWith(c) && l.length > c.length && (l[c.length] == "+" || l[c.length] == "-")))
-      return diff;
-    return lines.map((l) => l.startsWith(c) ? l.substring(c.length) : l).join("\n");
-  }
-  static StripIndent(s, fileLines) {
-    if (s == null || s.length == 0)
-      return s;
-    const stripped = s.replace(/^[ \t]{2,}/, "");
-    if (fileLines && stripped.length > 1 && stripped[0] === "-" && stripped[1] === " ") {
-      return DiffContentHeuristics.ResolveHyphenSpaceAmbiguity(s, stripped, fileLines);
-    }
-    if (fileLines && stripped.length > 0 && stripped[0] === "+" && fileLines.some((f) => f.trim() == stripped.trimEnd()))
-      return s;
-    return DiffContentHeuristics.IsValidDiffLineStart(stripped) ? stripped : s;
-  }
-  static TryParseFileHeader(line) {
-    if (!(line.startsWith("diff --git ") || line.startsWith("--- ") || line.startsWith("+++ "))) {
-      return null;
-    }
-    const path = line.startsWith("diff --git ") ? _UnifiedDiffParser.Canon(line.split(" ").filter((s) => s.length > 0)[2]) : _UnifiedDiffParser.Canon(line.length >= 4 ? line.substring(4) : "");
-    return path;
-  }
-  // Inside a hunk body, `--- foo` could be deletion of `-- foo` (SQL comment,
-  // prose) and `+++ foo` insertion of `++ foo` — or the next file's header.
-  // Evidence ladder: a transition to a file we HOLD
-  // is a real header; otherwise content decides — the delete reading wins when
-  // the current file contains `-- foo` verbatim, the insert reading when the
-  // body so far is a verified diff-shaped region (real header pairs never hit
-  // this: their `+++` follows a header-read `---`, which ends the body). Only
-  // in an evidence vacuum does the structure heuristic decide: real paths have
-  // `.` (extension) or `/` (directory); prose doesn't.
-  static IsFileHeader(line, path, inHunkBody, files, fileLineSet, body, fileLines) {
-    if (!inHunkBody)
-      return true;
-    if (line.startsWith("diff --git "))
-      return true;
-    if (path != "" && files?.has(path))
-      return true;
-    if (line.startsWith("--- ") && fileLineSet != null && fileLineSet.has(line.slice(1).replace(/\s+$/, "")))
-      return false;
-    if (line.startsWith("+++ ") && body != null && DiffContentHeuristics.IsDiffShapedRegion(body, fileLines))
-      return false;
-    return _UnifiedDiffParser.LooksLikePath(path);
-  }
-  static LooksLikePath(path) {
-    return path.includes(".") || path.includes("/") || path.includes("\\") || path === "/dev/null";
-  }
-  static Canon(p) {
-    if (p == null || p.length == 0)
-      return p;
-    p = p.trim();
-    if (p.startsWith("a/") || p.startsWith("b/"))
-      p = p.substring(2);
-    return p;
-  }
-  static TryParseHunkHeader(line) {
-    const t = line.trim();
-    if (!t.startsWith("@@"))
-      return null;
-    let header = new Header();
-    const parts = t.replace(/^[@ ]+|[@ ]+$/g, "").split(" ").filter((s) => s.length > 0);
-    if (parts.length > 0)
-      header = Header.ParseSide(header, parts[0], "-", true);
-    if (parts.length > 1)
-      header = Header.ParseSide(header, parts[1], "+", false);
-    return header;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/anchorer/hunkSlicer.js
-var Block = class {
-  StartIndex;
-  EndIndex;
-  DeleteLines;
-  InsertLines;
-  constructor(StartIndex, EndIndex, DeleteLines, InsertLines) {
-    this.StartIndex = StartIndex;
-    this.EndIndex = EndIndex;
-    this.DeleteLines = DeleteLines;
-    this.InsertLines = InsertLines;
-  }
-};
-var SlicedHunk = class {
-  Hunk;
-  Blocks;
-  constructor(Hunk2, Blocks) {
-    this.Hunk = Hunk2;
-    this.Blocks = Blocks;
-  }
-};
-var HunkSlicer = class _HunkSlicer {
-  static Slice(hunks) {
-    return Array.from(hunks).map((h) => new SlicedHunk(h, Array.from(_HunkSlicer.SliceHunk(h))));
-  }
-  static *SliceHunk(hunk) {
-    const lines = hunk.Lines;
-    if (lines == null || lines.length == 0) {
-      return;
-    }
-    let i = 0;
-    while (i < lines.length) {
-      if (lines[i].Type == LineType.Context) {
-        i++;
-        continue;
-      }
-      const start = i;
-      const del = [];
-      const ins = [];
-      while (i < lines.length && lines[i].Type != LineType.Context) {
-        const l = lines[i++];
-        if (l.Type == LineType.Delete)
-          del.push(l.Text);
-        else if (l.Type == LineType.Insert)
-          ins.push(l.Text);
-      }
-      const end = i - 1;
-      if (del.length > 0 || ins.length > 0)
-        yield new Block(start, end, del, ins);
-    }
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/anchorer/search.js
-var Match = class {
-  LineIndex;
-  Fuzz;
-  constructor(LineIndex, Fuzz) {
-    this.LineIndex = LineIndex;
-    this.Fuzz = Fuzz;
-  }
-};
-var Search = class _Search {
-  // Whitespace matching modes with their per-line fuzz
-  static StrictnessPasses = [
-    { Transform: (s) => s, Fuzz: 0 },
-    // exact
-    { Transform: (s) => s.trimEnd(), Fuzz: 1 },
-    // rstrip
-    { Transform: (s) => s.trim(), Fuzz: 100 },
-    // strip
-    { Transform: (s) => TextUtils.NormalizeHomoglyphs(s).trim(), Fuzz: 200 },
-    // homoglyphs + strip
-    { Transform: (s) => TextUtils.NormalizeHomoglyphs(TextUtils.StripInvisibles(s)).trim(), Fuzz: 300 },
-    // invisibles stripped + homoglyphs + strip
-    { Transform: (s) => TextUtils.NormalizeHomoglyphs(TextUtils.FoldCanonicalAndFullwidth(TextUtils.StripInvisibles(s))).trim(), Fuzz: 400 }
-    // + NFC and fullwidth folds
-  ];
-  /// <summary>
-  /// Attempts to locate <paramref name="needle"/> inside <paramref name="haystack"/>,
-  /// applying the strictness passes in order, strictest first.
-  /// Returns a FindResult with Index == -1 if no match.
-  /// Passes whose per-line fuzz exceeds <paramref name="maxPassFuzz"/> are skipped:
-  /// callers that treat a match as evidence the file already contains specific text
-  /// (rather than as an anchor to edit) pass 100 to exclude the homoglyph and
-  /// invisible-stripping passes.
-  /// </summary>
-  static Find(haystack, needle, startIndex = 0, maxPassFuzz = Number.MAX_SAFE_INTEGER) {
-    if (needle.length == 0)
-      return new Match(Math.min(Math.max(startIndex, 0), haystack.length), 0);
-    if (haystack.length < needle.length)
-      return new Match(-1, 0);
-    for (const { Transform: transform, Fuzz: fuzz } of _Search.StrictnessPasses.filter((p) => p.Fuzz <= maxPassFuzz)) {
-      const transformedNeedle = Array.from(needle).map(transform);
-      for (let i = startIndex; i <= haystack.length - needle.length; i++) {
-        let match = true;
-        for (let j = 0; j < needle.length; j++) {
-          if (transform(haystack[i + j]) != transformedNeedle[j]) {
-            match = false;
-            break;
-          }
-        }
-        if (!match)
-          continue;
-        let affected = 0;
-        for (let k = 0; k < needle.length; k++) {
-          if (transform(haystack[i + k]) != haystack[i + k] || transformedNeedle[k] != needle[k])
-            affected++;
-        }
-        return new Match(i, fuzz * affected);
-      }
-    }
-    return new Match(-1, 0);
-  }
-  /// <summary>
-  /// True when two lines are equal under any of the strictness passes the anchor
-  /// search itself uses. Used to revalidate context at a line-number-tiebroken slot:
-  /// the revalidation must not be stricter than the search that produced the
-  /// candidates, or slots the search considered equivalent (indent slop, homoglyphs)
-  /// get rejected loudly instead of applied.
-  /// </summary>
-  static LinesEquivalent(a, b) {
-    return _Search.StrictnessPasses.some((p) => p.Transform(a) == p.Transform(b));
-  }
-  /// <summary>
-  /// Attempts to find a unique match and reports ambiguity without requiring a separate call.
-  /// Success=true when exactly one match; Ambiguous=true when more than one match exists; both false when none.
-  /// </summary>
-  static FindUnique(haystack, needle) {
-    const first = _Search.Find(haystack, needle);
-    if (first.LineIndex < 0)
-      return UniqueMatch.NotFound;
-    const second = _Search.Find(haystack, needle, first.LineIndex + 1);
-    if (second.LineIndex >= 0)
-      return UniqueMatch.Ambiguous;
-    return new UniqueMatch(MatchState.Success, first.LineIndex, first.Fuzz);
-  }
-  /// <summary>
-  /// Finds the best insertion anchor for a pure-insert hunk using provided context lines.
-  /// Attempts, in order: full pattern (pre+post), pre-only (insert after pre), post-only (insert before post).
-  /// If none uniquely match, returns a non-success result with Ambiguous flag when any side matches somewhere.
-  /// </summary>
-  static FindContextAnchor(haystack, contextBefore, contextAfter) {
-    const preCount = contextBefore.length;
-    let sawAmbiguity = false;
-    const searchPatterns = [
-      { pattern: contextBefore.concat(contextAfter), insertIndex: preCount, condition: preCount + contextAfter.length > 0 },
-      { pattern: contextBefore, insertIndex: preCount, condition: preCount > 0 },
-      { pattern: contextAfter, insertIndex: 0, condition: contextAfter.length > 0 }
-    ];
-    for (const { pattern, insertIndex, condition } of searchPatterns) {
-      if (!condition)
-        continue;
-      const match = _Search.FindUnique(haystack, pattern);
-      if (match.IsSuccess)
-        return new UniqueMatch(MatchState.Success, match.LineIndex + insertIndex, match.Fuzz);
-      if (match.IsAmbiguous)
-        sawAmbiguity = true;
-    }
-    return new UniqueMatch(sawAmbiguity ? MatchState.Ambiguous : MatchState.NotFound);
-  }
-  /// <summary>
-  /// Returns every position in <paramref name="haystack"/> where <paramref name="needle"/>
-  /// matches exactly (no whitespace fuzz). Used for line-number tiebreaking among
-  /// ambiguous candidates — we deliberately exclude fuzzy matches so the candidate set
-  /// reflects only positions the LLM could plausibly have meant.
-  /// </summary>
-  static FindAllExact(haystack, needle) {
-    const results = [];
-    if (needle.length == 0)
-      return results;
-    for (let i = 0; i + needle.length <= haystack.length; i++)
-      if (needle.every((v, j) => haystack[i + j] === v))
-        results.push(i);
-    return results;
-  }
-  static TiebreakByLineNumber(candidates, expectedLine) {
-    if (candidates.length == 0)
-      return null;
-    if (candidates.length == 1)
-      return candidates[0];
-    const sorted = ArrayUtils.OrderBy(candidates.map((c) => ({ line: c, dist: Math.abs(c - expectedLine) })), (x) => x.dist);
-    if (sorted[0].dist == 0)
-      return sorted[0].line;
-    const gapToNext = sorted[1].dist - sorted[0].dist;
-    if (gapToNext > sorted[0].dist * 10)
-      return sorted[0].line;
-    return null;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/anchorer/blockAnchorer.js
-var BlockAnchorer = class _BlockAnchorer {
-  static AnchorBlocks(hunk, blocks, lines, options) {
-    return blocks.map((focus, index) => {
-      let aboveEdge = focus.StartIndex;
-      let belowEdge = focus.EndIndex;
-      let aboveBlockIdx = index - 1;
-      let belowBlockIdx = index + 1;
-      let chunk = null;
-      const suppliedAbove = _BlockAnchorer.ContextLines(hunk, focus.StartIndex - 1, index > 0 ? blocks[index - 1].EndIndex + 1 : 0, Number.MAX_SAFE_INTEGER, true);
-      const suppliedBelow = _BlockAnchorer.ContextLines(hunk, focus.EndIndex + 1, index < blocks.length - 1 ? blocks[index + 1].StartIndex - 1 : hunk.Lines.length - 1, Number.MAX_SAFE_INTEGER, false);
-      while (true) {
-        const aboveBound = aboveBlockIdx >= 0 ? blocks[aboveBlockIdx].EndIndex + 1 : 0;
-        const belowBound = belowBlockIdx < blocks.length ? blocks[belowBlockIdx].StartIndex - 1 : hunk.Lines.length - 1;
-        for (let k = 1; k <= options.ContextWindowMax; k++) {
-          const ctxAbove = _BlockAnchorer.ContextLines(hunk, aboveEdge - 1, aboveBound, k, true);
-          const ctxBelow = _BlockAnchorer.ContextLines(hunk, belowEdge + 1, belowBound, k, false);
-          const needle = _BlockAnchorer.BuildNeedle(hunk, aboveEdge, belowEdge);
-          const match = _BlockAnchorer.Anchor(lines, ctxAbove, needle, ctxBelow);
-          chunk = new Chunk(aboveEdge == focus.StartIndex ? ctxAbove : _BlockAnchorer.ContextLines(hunk, focus.StartIndex - 1, 0, k, true), focus.DeleteLines, focus.InsertLines, belowEdge == focus.EndIndex ? ctxBelow : _BlockAnchorer.ContextLines(hunk, focus.EndIndex + 1, hunk.Lines.length - 1, k, false), _BlockAnchorer.AlignMatchToFocus(match, hunk, aboveEdge, focus.StartIndex), new DiffLocation(hunk, focus.StartIndex, focus.EndIndex));
-          chunk.SuppliedContextBefore = suppliedAbove;
-          chunk.SuppliedContextAfter = suppliedBelow;
-          if (!chunk.Match.IsAmbiguous)
-            return chunk;
-          if (ctxAbove.length < k && ctxBelow.length < k)
-            break;
-        }
-        if (aboveBlockIdx < 0 && belowBlockIdx >= blocks.length)
-          break;
-        const ctxAboveCount = aboveBlockIdx >= 0 ? aboveEdge - (blocks[aboveBlockIdx].EndIndex + 1) : Number.MAX_SAFE_INTEGER;
-        const ctxBelowCount = belowBlockIdx < blocks.length ? blocks[belowBlockIdx].StartIndex - (belowEdge + 1) : Number.MAX_SAFE_INTEGER;
-        if (ctxBelowCount <= ctxAboveCount && belowBlockIdx < blocks.length)
-          belowEdge = blocks[belowBlockIdx++].EndIndex;
-        else
-          aboveEdge = blocks[aboveBlockIdx--].StartIndex;
-      }
-      if (chunk.Match.IsAmbiguous && hunk.OldStart >= 0) {
-        const tiebroken = _BlockAnchorer.TryLineNumberTiebreak(hunk, focus, lines);
-        if (tiebroken != null)
-          chunk = chunk.with({ Match: tiebroken });
-      }
-      return chunk;
-    });
-  }
-  static TryLineNumberTiebreak(hunk, focus, lines) {
-    let expectedLine = hunk.OldStart - 1;
-    for (let i = 0; i < focus.StartIndex; i++)
-      if (hunk.Lines[i].Type != LineType.Insert)
-        expectedLine++;
-    if (focus.DeleteLines.length == 0) {
-      if (expectedLine < 0 || expectedLine > lines.length)
-        return null;
-      if (!_BlockAnchorer.CtxMatchesAtSlot(hunk, focus, lines, expectedLine))
-        return null;
-      return new UniqueMatch(MatchState.Success, expectedLine);
-    }
-    const candidates = Search.FindAllExact(lines, focus.DeleteLines);
-    const resolved = Search.TiebreakByLineNumber(candidates, expectedLine);
-    return resolved != null && _BlockAnchorer.CtxMatchesAtSlot(hunk, focus, lines, resolved) ? new UniqueMatch(MatchState.Success, resolved) : null;
-  }
-  // Validates the hunk's immediate context lines against a resolved slot's
-  // neighbours so a stale or shifted header errs loudly instead of silently
-  // mis-placing the edit. Content-bearing context compares under the search's own
-  // strictness ladder — the revalidation must not be stricter than the search that
-  // produced the candidates, or indent-slopped slots the search matched get
-  // rejected loudly. But a line that trims to near-nothing (brace/paren-only)
-  // carries its signal IN the indentation, which every ladder pass beyond rstrip
-  // erases — such context stays whitespace-right-trimmed strict, or a shifted
-  // header walks the edit to any same-shaped brace. Both tolerances corpus-measured
-  // 2026-07-06 (ladder-everywhere: 3 silent mis-applies; this gate: 0, +14 recall).
-  // Serves both callers: a pure insert (DeleteLines empty, after-context sits at
-  // `slot`) and a delete-block tiebreak (deletes occupy [slot, slot + DeleteLines.length)).
-  static CtxMatchesAtSlot(hunk, focus, lines, slot) {
-    const MinLadderContent = 3;
-    const matches = (hunkIdx, lineIdx) => {
-      if (hunkIdx < 0 || hunkIdx >= hunk.Lines.length || hunk.Lines[hunkIdx].Type != LineType.Context)
-        return true;
-      if (lineIdx < 0 || lineIdx >= lines.length)
-        return false;
-      const text = hunk.Lines[hunkIdx].Text;
-      return text.trim().length >= MinLadderContent ? Search.LinesEquivalent(lines[lineIdx], text) : lines[lineIdx].trimEnd() == text.trimEnd();
-    };
-    return matches(focus.StartIndex - 1, slot - 1) && matches(focus.EndIndex + 1, slot + focus.DeleteLines.length);
-  }
-  static AlignMatchToFocus(match, hunk, needleStartIndex, focusStartIndex) {
-    if (!match.IsSuccess)
-      return match;
-    return new UniqueMatch(match.State, match.LineIndex + hunk.Lines.slice(needleStartIndex, focusStartIndex).filter((l) => l.Type != LineType.Insert).length, match.Fuzz);
-  }
-  static ContextLines(hunk, startLine, bound, maxTake, isAbove) {
-    if (maxTake <= 0)
-      return [];
-    const lines = [];
-    for (let i = 0; i < maxTake; i++) {
-      const index = startLine + (isAbove ? -i : i);
-      if (!(index >= 0 && index < hunk.Lines.length))
-        break;
-      if (!(isAbove ? index >= bound : index <= bound))
-        break;
-      const line = hunk.Lines[index];
-      if (line.Type != LineType.Context)
-        break;
-      lines.push(line.Text);
-    }
-    return isAbove ? [...lines].reverse() : lines;
-  }
-  static BuildNeedle(h, startIndex, endIndex) {
-    return h.Lines.slice(startIndex, endIndex + 1).filter((line) => line.Type != LineType.Insert).map((line) => line.Text);
-  }
-  static Anchor(lines, contextAbove, deleteLines, contextBelow) {
-    if (deleteLines.length == 0)
-      return Search.FindContextAnchor(lines, contextAbove, contextBelow);
-    const pattern = contextAbove.concat(deleteLines).concat(contextBelow);
-    const match = Search.FindUnique(lines, pattern);
-    if (match.IsAmbiguous)
-      return UniqueMatch.Ambiguous;
-    if (match.IsSuccess)
-      return new UniqueMatch(match.State, match.LineIndex + contextAbove.length, match.Fuzz);
-    return Search.FindUnique(lines, deleteLines);
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/anchorer/hunkAnchorer.js
-var AnchorOutcome = class {
-  Chunks;
-  AlreadyAppliedCount;
-  constructor(Chunks, AlreadyAppliedCount) {
-    this.Chunks = Chunks;
-    this.AlreadyAppliedCount = AlreadyAppliedCount;
-  }
-};
-var HunkAnchorer = class _HunkAnchorer {
-  /// <param name="hunkWasSkipped">A hunk of this diff stated no change and was dropped at
-  /// parse time — so an unpositioned insert here may be the orphaned half of a split hunk
-  /// whose anchor went with it. See UseFallbackAnchorIfNecessary.</param>
-  static Anchor(originalText, hunks, options, hunkWasSkipped = false) {
-    const lines = TextUtils.ToLines(originalText);
-    const slicedHunks = HunkSlicer.Slice(hunks);
-    const chunks = [];
-    for (const sliced of slicedHunks)
-      for (const chunk of BlockAnchorer.AnchorBlocks(sliced.Hunk, sliced.Blocks, lines, options))
-        chunks.push(_HunkAnchorer.UseFallbackAnchorIfNecessary(sliced.Hunk, chunk, lines, hunkWasSkipped));
-    const deleteCounts = /* @__PURE__ */ new Map();
-    for (const l of chunks.flatMap((c) => c.DeleteLines))
-      if (l.trim().length > 0)
-        deleteCounts.set(l, (deleteCounts.get(l) ?? 0) + 1);
-    const movedFromElsewhere = (c, line) => (deleteCounts.get(line) ?? 0) > c.DeleteLines.filter((d) => d === line).length;
-    const kept = chunks.filter((c) => !_HunkAnchorer.AppliedAtAnchor(lines, c) && (c.InsertLines.some((l) => movedFromElsewhere(c, l)) || !_HunkAnchorer.AlreadyApplied(lines, c))).map((c) => _HunkAnchorer.TrySubLineSplice(c, lines));
-    return new AnchorOutcome(kept, chunks.length - kept.length);
-  }
-  static UseFallbackAnchorIfNecessary(hunk, chunk, lines, hunkWasSkipped) {
-    const lineCount = lines.length;
-    if (chunk.Match.IsNotFound && hunk.Lines.length == chunk.InsertLines.length) {
-      const targetIsEmpty = lineCount == 0 || lineCount == 1 && lines[0].length == 0;
-      if (hunk.OldStart < 0 && hunkWasSkipped && !targetIsEmpty)
-        return chunk;
-      const anchorLine = hunk.OldStart <= 1 ? 0 : hunk.OldStart;
-      if (anchorLine > lineCount)
-        return chunk;
-      return chunk.with({ Match: new UniqueMatch(MatchState.Success, anchorLine) });
-    }
-    return chunk;
-  }
-  // Sub-line splice fallback: a delete line that matches no file line but occurs
-  // as a substring of exactly one line is an author-quoted fragment — an author
-  // cannot intend to delete text they never mentioned, so the only coherent
-  // reading replaces the fragment within the line and preserves the rest. Every
-  // guard failure means fragment-vs-mangled-whole-line is undecidable: the chunk
-  // stays NotFound and errors loudly. The insert-side guards catch damaged
-  // whole-line edits: an insert that echoes text from outside the fragment, or
-  // dwarfs it, was authored by someone who saw the whole line.
-  // MUST run only on chunks that survived the already-applied filter: an applied
-  // edit that wrapped the old line (comment-out, prefix insertion) leaves the
-  // delete line as a substring of the new line, and splicing it again would
-  // stack the wrapper (corpus wave-1 case 177: "#x" became "##x").
-  static TrySubLineSplice(chunk, lines) {
-    if (!chunk.Match.IsNotFound || chunk.DeleteLines.length != 1 || chunk.InsertLines.length > 1)
-      return chunk;
-    const frag = chunk.DeleteLines[0];
-    if (frag.trim().length < _HunkAnchorer.MinSpliceFragmentContent)
-      return chunk;
-    let lineIndex = -1;
-    for (let i = 0; i < lines.length; i++) {
-      const first = lines[i].indexOf(frag);
-      if (first < 0)
-        continue;
-      const again = lines[i].indexOf(frag, first + 1) >= 0;
-      if (lineIndex >= 0 || again)
-        return chunk;
-      lineIndex = i;
-    }
-    if (lineIndex < 0)
-      return chunk;
-    const target = lines[lineIndex];
-    const at = target.indexOf(frag);
-    const prefix = target.slice(0, at), suffix = target.slice(at + frag.length);
-    const insert = chunk.InsertLines.length == 1 ? chunk.InsertLines[0] : "";
-    if (prefix.length == 0 && suffix.length > 0)
-      return chunk;
-    if (insert.length == 0 && prefix.length > 0 && suffix.length > 0 && /\s/.test(prefix[prefix.length - 1]) && /\s/.test(suffix[0]))
-      return chunk;
-    const remnantOk = (r) => r.length == 0 || r.trim().length >= _HunkAnchorer.MinSpliceRemnantContent;
-    const echoes = (r) => r.length > 0 && insert.includes(r.trim());
-    if (!remnantOk(prefix) || !remnantOk(suffix) || echoes(prefix) || echoes(suffix) || insert.length > frag.length * 2 + 8 && _HunkAnchorer.SharedStem(frag, insert) < _HunkAnchorer.MinSpliceStemContent)
-      return chunk;
-    return chunk.with({
-      ContextBefore: [],
-      DeleteLines: [target],
-      InsertLines: [prefix + insert + suffix],
-      ContextAfter: [],
-      Match: new UniqueMatch(MatchState.Success, lineIndex, _HunkAnchorer.SubLineSpliceFuzz)
-    });
-  }
-  // Trimmed length a fragment must reach before substring evidence counts.
-  static MinSpliceFragmentContent = 8;
-  // Trimmed length a non-empty out-of-fragment remnant must carry.
-  static MinSpliceRemnantContent = 4;
-  // Trimmed length the fragment/insert shared stem must reach to waive the dwarf cap.
-  static MinSpliceStemContent = 8;
-  // The longest run the insert shares with the fragment's start or end, in trimmed
-  // chars — the fragment-edit evidence that waives the dwarf cap.
-  static SharedStem(frag, insert) {
-    let p = 0;
-    while (p < frag.length && p < insert.length && frag[p] == insert[p])
-      p++;
-    let s = 0;
-    while (s < frag.length && s < insert.length && frag[frag.length - 1 - s] == insert[insert.length - 1 - s])
-      s++;
-    return Math.max(frag.slice(0, p).trim().length, s == 0 ? 0 : frag.slice(-s).trim().length);
-  }
-  // Reported fuzz for a spliced edit: looser than every line-match pass.
-  static SubLineSpliceFuzz = 500;
-  // A sanity check to avoid errors for a chunk that is already applied.
-  // Asymmetric strictness: insert-side evidence is capped at whitespace-level
-  // passes (a homoglyph variant of the post-image is not proof the edit landed,
-  // and would turn a loud MatchNotFound into a silent no-op), while the delete
-  // side stays uncapped (finding the pre-image even loosely proves the edit is
-  // still pending, blocking a false already-applied verdict).
-  static AlreadyApplied(lines, c) {
-    if (!c.HasContextLines() && (c.IsPureDelete || c.IsPureInsert))
-      return false;
-    const insertImage = c.HasContextLines() ? c.InsertLinesWithContext() : c.InsertLines;
-    const deleteImage = c.HasContextLines() ? c.DeleteLinesWithContext() : c.DeleteLines;
-    const insertAt = Search.Find(lines, insertImage, 0, _HunkAnchorer.MaxAppliedEvidenceFuzz);
-    return insertAt.LineIndex != -1 && Search.Find(lines, deleteImage).LineIndex == -1 && !_HunkAnchorer.OldImagePresentElsewhere(lines, c.DeleteLines, c.IsPureDelete ? null : insertImage, insertAt.LineIndex);
-  }
-  // Veto on the already-applied verdict: "old image absent" cannot
-  // distinguish an applied edit from a delete block damaged in transit — one bad
-  // char defeats every search pass — so a window nearly matching the delete block
-  // proves the old image is still in the file and the edit pending: keep the chunk
-  // and let it error loudly. Refinements, each forced by a corpus counter-example:
-  // - Windows overlapping an insert-image occurrence never veto: after a genuine
-  //   apply the region shares most lines with the old image (rewrites re-state
-  //   unchanged lines as -/+), and vetoing there would break idempotent re-apply.
-  // - Pure deletes skip that exclusion (exclusionImage = null): their post-image
-  //   is thin context that occurs everywhere — even inside the pending block
-  //   itself — so its occurrences prove nothing.
-  // - The window is the delete block WITHOUT context: context sits in both images
-  //   and would glue the pending old image to a context match, masking it.
-  // - Only content-bearing lines vote, with an absolute floor: blank/brace lines
-  //   near-match everywhere and tiny blocks carry too little signal either way.
-  static OldImagePresentElsewhere(lines, dels, exclusionImage, insertIndex) {
-    const contentIdx = [...dels.keys()].filter((i) => dels[i].trim().length > 0);
-    if (contentIdx.length < _HunkAnchorer.MinNearImageMatches)
-      return false;
-    const insertStarts = exclusionImage == null ? [] : [...Search.FindAllExact(lines, exclusionImage), insertIndex];
-    const overlapsInsert = (start) => insertStarts.some((s) => start < s + exclusionImage.length && s < start + dels.length);
-    for (let start = 0; start + dels.length <= lines.length; start++) {
-      if (overlapsInsert(start))
-        continue;
-      const matched = contentIdx.filter((j) => lines[start + j] === dels[j]).length;
-      if (matched >= _HunkAnchorer.MinNearImageMatches && matched * 2 > contentIdx.length)
-        return true;
-    }
-    return false;
-  }
-  // Exact-matching content lines required before a near-old-image window counts.
-  static MinNearImageMatches = 3;
-  // Highest per-line fuzz (strip pass) that still counts as already-applied evidence.
-  static MaxAppliedEvidenceFuzz = 100;
-  // A successfully anchored pure-insert chunk whose full post-image (context +
-  // inserted lines + context) already sits at the resolved slot — or immediately
-  // before it — would duplicate itself if applied: the file already reflects this
-  // chunk. Including the context lines in the comparison distinguishes "already
-  // applied" from a diff that intentionally duplicates adjacent lines (there the
-  // old-side context sits where the copy would be, so the post-image cannot match).
-  static AppliedAtAnchor(lines, c) {
-    if (!c.IsPureInsert || !c.Match.IsSuccess)
-      return false;
-    const post = c.InsertLinesWithContext();
-    const slot = c.Match.LineIndex;
-    return _HunkAnchorer.RegionEquals(lines, slot - c.ContextBefore.length, post) || _HunkAnchorer.RegionEquals(lines, slot - c.ContextBefore.length - c.InsertLines.length, post);
-  }
-  static RegionEquals(lines, start, region) {
-    if (start < 0 || start + region.length > lines.length)
-      return false;
-    for (let i = 0; i < region.length; i++)
-      if (lines[start + i] !== region[i])
-        return false;
-    return true;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/anchorer/contextAuditor.js
-var ContextDivergence = class _ContextDivergence {
-  ContextText;
-  FileText;
-  DiffLine;
-  FileLine;
-  constructor(ContextText, FileText, DiffLine2, FileLine) {
-    this.ContextText = ContextText;
-    this.FileText = FileText;
-    this.DiffLine = DiffLine2;
-    this.FileLine = FileLine;
-  }
-  // Mirrors Edit.Shift: selection-scoped callers see true file coordinates.
-  Shift(lineDelta) {
-    return new _ContextDivergence(this.ContextText, this.FileText, this.DiffLine, this.FileLine + lineDelta);
-  }
-};
-var ContextAuditor = class _ContextAuditor {
-  static Audit(appliedChunks, lines) {
-    const divergences = appliedChunks.filter((c) => c.Match.IsSuccess).flatMap((c) => [
-      ..._ContextAuditor.AuditRun(c.SuppliedContextBefore, c.Match.LineIndex - c.SuppliedContextBefore.length, lines, c),
-      ..._ContextAuditor.AuditRun(c.SuppliedContextAfter, c.Match.LineIndex + c.DeleteLines.length, lines, c)
-    ]);
-    const seen = /* @__PURE__ */ new Set();
-    return divergences.filter((d) => seen.has(d.ContextText) ? false : (seen.add(d.ContextText), true));
-  }
-  // `run` is in file order; `startIndex` is the claimed position of its first line.
-  static AuditRun(run, startIndex, lines, chunk) {
-    return run.map((ctx, i) => _ContextAuditor.AuditLine(ctx, startIndex + i, lines, chunk)).filter((d) => d != null);
-  }
-  static AuditLine(ctx, at, lines, chunk) {
-    if (ctx.trim().length == 0)
-      return null;
-    const inRange = at >= 0 && at < lines.length;
-    if (inRange && Search.LinesEquivalent(lines[at], ctx))
-      return null;
-    if (lines.some((l) => Search.LinesEquivalent(l, ctx)))
-      return null;
-    return new ContextDivergence(ctx, inRange ? lines[at] : null, chunk.DiffLocation?.StartLine ?? -1, inRange ? at + 1 : chunk.Match.LineIndex + 1);
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/selectionTarget.js
-var SelectionTarget = class {
-  FullText;
-  SelectedText;
-  UseSelection = false;
-  LineOffset = 0;
-  get TargetText() {
-    return this.UseSelection ? this.SelectedText : this.FullText;
-  }
-  constructor(fullText, selection = "") {
-    this.FullText = fullText;
-    this.SelectedText = selection;
-    if (!(this.SelectedText == null || this.SelectedText.length == 0)) {
-      const hay = TextUtils.ToLines(this.FullText);
-      const needle = TextUtils.ToLines(this.SelectedText);
-      const result = Search.Find(hay, needle);
-      this.UseSelection = result.LineIndex >= 0;
-      this.LineOffset = this.UseSelection ? Math.max(0, result.LineIndex) : 0;
-    }
-  }
-  Replace(replace) {
-    if (!this.UseSelection)
-      return replace;
-    const fullLines = TextUtils.ToLines(this.FullText);
-    const selectionLines = TextUtils.ToLines(this.SelectedText);
-    const replaceLines = TextUtils.ToLines(replace);
-    const edit = new Edit(this.LineOffset, selectionLines, replaceLines);
-    edit.ApplyTo(fullLines);
-    return TextUtils.RoundTripWhitespace(this.FullText, fullLines);
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/sanitizers/shared.js
-function isDiffMarker(line) {
-  return line.startsWith("--- ") || line.startsWith("+++ ") || line.startsWith("@@") || line.startsWith("diff --git");
-}
-function isHunkBoundary(line, trimmed) {
-  return isDiffMarker(line) || trimmed.startsWith("```");
-}
-function isValidPrefix(char) {
-  return char === "+" || char === "-" || char === " ";
-}
-function transformOutsideHunkBodies(text, transform) {
-  let remainingOld = 0, remainingNew = 0;
-  let inBareBody = false;
-  const kept = [];
-  for (const line of text.split("\n")) {
-    const trimmed = line.trim();
-    const m = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/.exec(trimmed);
-    if (m) {
-      remainingOld = m[1] !== void 0 ? parseInt(m[1]) : 1;
-      remainingNew = m[2] !== void 0 ? parseInt(m[2]) : 1;
-      inBareBody = false;
-      kept.push(line);
-      continue;
-    }
-    if (remainingOld > 0 || remainingNew > 0) {
-      const c = line.length > 0 ? line[0] : " ";
-      if (c === "-")
-        remainingOld--;
-      else if (c === "+")
-        remainingNew--;
-      else {
-        remainingOld--;
-        remainingNew--;
-      }
-      kept.push(line);
-      continue;
-    }
-    if (trimmed.startsWith("@@")) {
-      inBareBody = true;
-      kept.push(line);
-      continue;
-    }
-    if (inBareBody && line.length > 0 && isValidPrefix(line[0]) && !isLikelyFileHeader(trimmed)) {
-      kept.push(line);
-      continue;
-    }
-    inBareBody = false;
-    const t = transform(line);
-    if (t !== null)
-      kept.push(t);
-  }
-  return kept.join("\n");
-}
-function isLikelyFileHeader(trimmed) {
-  return trimmed.startsWith("diff --git") || (trimmed.startsWith("--- ") || trimmed.startsWith("+++ ")) && (trimmed.includes(".") || trimmed.includes("/") || trimmed.includes("\\"));
-}
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/sanitizers/customFormatSanitizer.js
-var CustomFormatSanitizer = class _CustomFormatSanitizer {
-  static OPERATIONS = [
-    { header: /^\s*\*\*\* Update File: (.+)$/i, fromPath: (p) => `a/${p}`, toPath: (p) => `b/${p}` },
-    { header: /^\s*\*\*\* Add File: (.+)$/i, fromPath: (_p) => "/dev/null", toPath: (p) => `b/${p}` },
-    { header: /^\s*\*\*\* Delete File: (.+)$/i, fromPath: (p) => `a/${p}`, toPath: (_p) => "/dev/null" }
-  ];
-  static process(text) {
-    return transformOutsideHunkBodies(text, (line) => {
-      const hadCr = line.endsWith("\r");
-      const core = hadCr ? line.slice(0, -1) : line;
-      for (const op of _CustomFormatSanitizer.OPERATIONS) {
-        const m = core.match(op.header);
-        if (!m)
-          continue;
-        const path = m[1].trim();
-        const tail = hadCr ? "\r" : "";
-        return `--- ${op.fromPath(path)}${tail}
-+++ ${op.toPath(path)}${tail}`;
-      }
-      return line;
-    });
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/sanitizers/decoratedHeaderSanitizer.js
-var DecoratedHeaderSanitizer = class _DecoratedHeaderSanitizer {
-  static DECORATED_HEADER_REGEX = /^(---|\+\+\+)\s+(.+?)\s+(---|\+\+\+)+\s*$/;
-  static process(text) {
-    return transformOutsideHunkBodies(text, (line) => {
-      const hadCr = line.endsWith("\r");
-      const core = hadCr ? line.slice(0, -1) : line;
-      const replaced = core.replace(_DecoratedHeaderSanitizer.DECORATED_HEADER_REGEX, "$1 $2");
-      return replaced === core ? line : hadCr ? replaced + "\r" : replaced;
-    });
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/sanitizers/decorativeMarkerSanitizer.js
-var DecorativeMarkerSanitizer = class _DecorativeMarkerSanitizer {
-  static process(text) {
-    return transformOutsideHunkBodies(text, (line) => _DecorativeMarkerSanitizer.isDecorativeMarker(line.trim()) ? null : line);
-  }
-  static isDecorativeMarker(line) {
-    if (!line)
-      return false;
-    if (/^diff --git\s+/.test(line))
-      return false;
-    if (/^[*#_]{3,}$/.test(line))
-      return true;
-    if (/^[=\-]{5,}$/.test(line))
-      return true;
-    const wholeLineKeyword = /^[*=\-#_\s]*(BEGIN|END|START|STOP)\s+(PATCH|DIFF|HUNK|SECTION|BLOCK)[*=\-#_\s]*$/i.test(line);
-    if (wholeLineKeyword && /[*=\-#_]{2,}/.test(line))
-      return true;
-    return false;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/sanitizers/backtickSanitizer.js
-var BacktickSanitizer = class {
-  static process(text) {
-    return text.replace(/^```+\s*diff\b/gmi, "```diff").replace(/^```+$/gm, "```");
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/sanitizers/diffBlockReunifier.js
-var DiffBlockReunifier = class {
-  static process(text) {
-    const lines = text.split("\n");
-    const result = [];
-    let inDiff = false;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-      if (trimmed.startsWith("```diff")) {
-        inDiff = true;
-        result.push(line);
-      } else if (trimmed === "```" && line.startsWith("```")) {
-        if (inDiff && this.hasDiffContentBeforeNextFence(lines, i)) {
-          continue;
-        }
-        inDiff = false;
-        result.push(line);
-      } else {
-        result.push(line);
-      }
-    }
-    return result.join("\n");
-  }
-  static hasDiffContentBeforeNextFence(lines, currentIndex) {
-    for (let j = currentIndex + 1; j < lines.length; j++) {
-      const ahead = lines[j].trim();
-      if (lines[j].startsWith("```"))
-        return false;
-      if (isDiffMarker(ahead))
-        return true;
-    }
-    return false;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/sanitizers/devNullSanitizer.js
-var DevNullSanitizer = class {
-  static process(text, fileKeys) {
-    if (!fileKeys?.length)
-      return text;
-    const existingFiles = new Set(fileKeys);
-    const lines = text.split("\n");
-    const result = [];
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-      if (this.isNewFileModeForExistingFile(trimmed, lines, i, existingFiles)) {
-        continue;
-      }
-      if (trimmed.startsWith("--- /dev/null")) {
-        const targetFile = this.getTargetFileFromNextLine(lines[i + 1]);
-        if (targetFile && existingFiles.has(targetFile)) {
-          result.push(line.replace("/dev/null", `a/${targetFile}`));
-          continue;
-        }
-      }
-      result.push(line);
-    }
-    return result.join("\n");
-  }
-  static isNewFileModeForExistingFile(line, allLines, currentIndex, existingFiles) {
-    if (!line.startsWith("new file mode"))
-      return false;
-    const prevLine = allLines[currentIndex - 1]?.trim() || "";
-    if (!prevLine.startsWith("diff --git"))
-      return false;
-    const match = prevLine.match(/diff --git\s+[ab]\/(\S+)\s+[ab]\/\S+/);
-    const filePath = match?.[1];
-    return filePath ? existingFiles.has(filePath) : false;
-  }
-  static getTargetFileFromNextLine(nextLine) {
-    if (!nextLine?.trim().startsWith("+++ "))
-      return null;
-    const match = nextLine.match(/^\+\+\+\s+(?:[ab]\/)?(\S+)/);
-    return match?.[1] ?? null;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/sanitizers/prefixInjector.js
-var PrefixInjector = class {
-  static process(text) {
-    const lines = text.split("\n");
-    let inHunk = false;
-    let deletes = { remaining: 0, consumed: 0 };
-    let adds = { remaining: 0, consumed: 0 };
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.length === 0 && i === lines.length - 1)
-        continue;
-      const trimmed = line.trim();
-      if (trimmed.startsWith("@@")) {
-        const { deleteCount, addCount } = this.parseHunkHeader(trimmed);
-        inHunk = true;
-        deletes = { remaining: deleteCount, consumed: 0 };
-        adds = { remaining: addCount, consumed: 0 };
-        continue;
-      }
-      if (isHunkBoundary(line, trimmed)) {
-        inHunk = false;
-        continue;
-      }
-      if (inHunk) {
-        const first = line[0] ?? "";
-        const hasValidPrefix = isValidPrefix(first);
-        const prefix = hasValidPrefix ? first : this.inferPrefix(deletes.remaining - deletes.consumed, adds.remaining - adds.consumed);
-        if (!hasValidPrefix && prefix !== null) {
-          lines[i] = prefix + line;
-        }
-        if (prefix === "+")
-          adds.consumed++;
-        else if (prefix === "-")
-          deletes.consumed++;
-        else {
-          adds.consumed++;
-          deletes.consumed++;
-        }
-      }
-    }
-    return lines.join("\n");
-  }
-  static parseHunkHeader(header) {
-    const match = header.match(/@@\s*-(\d+)(?:,(\d+))?\s*\+(\d+)(?:,(\d+))?\s*@@/);
-    return match ? { deleteCount: parseInt(match[2] ?? "1"), addCount: parseInt(match[4] ?? "1") } : { deleteCount: 0, addCount: 0 };
-  }
-  // Only inject when the header arithmetic is unambiguous. When both deletes and
-  // adds remain (or the header had no usable counts), leave the line untouched —
-  // the parser's raw-line heuristics use content evidence and insertion-lookahead
-  // to classify it better than count-based guessing can.
-  static inferPrefix(remainingDeletes, remainingAdds) {
-    if (remainingDeletes > 0 && remainingAdds <= 0)
-      return "-";
-    if (remainingAdds > 0 && remainingDeletes <= 0)
-      return "+";
-    return null;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/parser/diffSanitizer.js
-var DiffSanitizer = class {
-  static Process(diff, fileKeys) {
-    if (!diff?.trim())
-      return diff;
-    let result = CustomFormatSanitizer.process(diff);
-    result = DecoratedHeaderSanitizer.process(result);
-    result = DecorativeMarkerSanitizer.process(result);
-    result = BacktickSanitizer.process(result);
-    result = DiffBlockReunifier.process(result);
-    result = DevNullSanitizer.process(result, fileKeys);
-    result = PrefixInjector.process(result);
-    return result;
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/headerlessRouter.js
-var HeaderlessRouter = class {
-  static Route(fileHunks, files, options) {
-    const group = fileHunks.find((g) => g.Key == "");
-    if (group == null || files.some((f) => f.Key == ""))
-      return [];
-    const probeOptions = Object.assign(new PatchOptions(), options, { ContinueOnError: true });
-    const candidates = files.filter((f) => {
-      const target = new SelectionTarget(f.InputFullText, f.InputSelectedText).TargetText;
-      const anchored = HunkAnchorer.Anchor(target, group.Hunks, probeOptions);
-      return ChunkApplier.Apply(target, anchored.Chunks, probeOptions).Errors.length == 0;
-    });
-    if (candidates.length == 1) {
-      fileHunks.splice(fileHunks.indexOf(group), 1);
-      const existing = fileHunks.find((g) => g.Key == candidates[0].Key);
-      if (existing)
-        existing.Hunks.push(...group.Hunks);
-      else
-        fileHunks.push(new FileHunkGroup(candidates[0].Key, group.Hunks));
-      return [];
-    }
-    return [candidates.length == 0 ? new PatchError("MatchNotFound", group.Hunks[0].ToUnanchoredChunk(), null, "The diff has no file headers and its content did not match any file being patched. Make sure context and deleted lines match the target file, and add '--- <file>' / '+++ <file>' headers naming it.") : new PatchError("MatchAmbiguous", group.Hunks[0].ToUnanchoredChunk(), candidates.map((f) => f.Key).join(", "), "The diff has no file headers and its content matched more than one file being patched. Add '--- <file>' / '+++ <file>' headers naming the intended file.")];
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/patchNotices.js
-var PatchNotices = class _PatchNotices {
-  static For(hunks, file, contextOnlyHunkLines, contextDivergences) {
-    const notices = [];
-    if (file.Edits.length === 0)
-      notices.push(file.AlreadyAppliedCount > 0 ? `Note: no edits were applied because the file already contains this change (${file.AlreadyAppliedCount} chunk(s) detected as already applied).` : "Note: no edits were applied \u2014 the diff parsed but expressed no change for this file.");
-    if (file.Fuzz > 0)
-      notices.push(`Note: applied with fuzz factor ${file.Fuzz} \u2014 the diff did not match exactly, so confirm the edits landed where you intended.`);
-    const suspects = TextUtils.DescribeSuspectCodePoints(file.Edits.flatMap((e) => e.InsertLines));
-    if (suspects)
-      notices.push(`Warning: written lines contain invisible or lookalike characters: ${suspects}. If these were authored as \\uXXXX escapes or plain ASCII, the tool-call layer may have mangled them; verify the file content.`);
-    const collapsed = hunks.flatMap((h) => h.Lines).filter((l) => l.CollapsedFrom != null).map((l) => l.CollapsedFrom);
-    if (collapsed.length > 0)
-      notices.push(`Note: ${collapsed.length} body line(s) starting '++' were read as sloppy doubled insert markers and written without the leading '+' (first: "${collapsed[0]}"). If the inserted content was meant to keep a '+' prefix (diff-shaped payload), verify the file.`);
-    if (hunks.some((h) => h.TruncationSuspected))
-      notices.push("Note: the diff's final hunk looks truncated (its header declares more lines than the body delivered). The delivered lines were applied; verify the tail of that change landed.");
-    if (hunks.some((h) => h.ControlCharsSuspected))
-      notices.push("Note: insert lines contained raw control characters and were written verbatim. That is usually transport damage rather than intended content; verify the written bytes.");
-    if (contextOnlyHunkLines.length > 0)
-      notices.push(`Note: the hunk${contextOnlyHunkLines.length === 1 ? "" : "s"} at diff line ${contextOnlyHunkLines.join(", ")} stated no change (context only), so nothing was applied there while the other edits landed. If an edit was intended, its '+'/'-' lines were lost \u2014 re-send that hunk and verify.`);
-    if (file.Edits.length > 0)
-      for (const d of contextDivergences)
-        notices.push((d.DiffLine > 0 ? `Note: the edit at diff line ${d.DiffLine} supplied a context line that appears nowhere in the file \u2014 ` : "Note: a supplied context line appears nowhere in the file \u2014 ") + (d.FileText != null ? `the diff said "${_PatchNotices.DivergenceQuote(d.ContextText, d.FileText)}", and at the spot the edit landed (file line ${d.FileLine}) the file reads "${_PatchNotices.DivergenceQuote(d.FileText, d.ContextText)}". ` : `the diff said "${_PatchNotices.DivergenceQuote(d.ContextText, null)}" beside an edit landing at the file's boundary (file line ${d.FileLine}), where the file has no adjacent line. `) + "The edit applied via its '-'/'+' lines alone; context lines only locate an edit. If that difference was an intended change, it was NOT applied \u2014 express it as a '-'/'+' pair.");
-    return notices;
-  }
-  // A quote window around the first character where the two lines diverge, so long
-  // prose lines that share a long head still display their difference.
-  static DivergenceQuote(line, other) {
-    const window = 72;
-    if (line.length <= window)
-      return line;
-    let p = 0;
-    if (other != null)
-      while (p < line.length && p < other.length && line[p] == other[p])
-        p++;
-    const start = Math.min(Math.max(p - Math.floor(window / 3), 0), line.length - window);
-    return (start > 0 ? "\u2026" : "") + line.slice(start, start + window) + (start + window < line.length ? "\u2026" : "");
-  }
-};
-
-// ../node_modules/.pnpm/matchu-patchu@0.3.5/node_modules/matchu-patchu/dist/patcher.js
-var Patcher = class {
-  static Apply(diff, files, options) {
-    options = options ?? new PatchOptions();
-    const fileKeys = files.map((f) => f.Key);
-    const fileContents = new Map(files.map((f) => [f.Key, f.InputFullText]));
-    diff = options.SanitizeDiff ? DiffSanitizer.Process(diff, fileKeys) : diff;
-    const fileHunks = UnifiedDiffParser.Parse(diff, fileContents, options.Truncation, options.ControlChars);
-    const routingErrors = HeaderlessRouter.Route(fileHunks, files, options);
-    const namedKeys = fileKeys.filter((k) => k != "");
-    const rosterHint = namedKeys.length > 0 ? `Files being patched: ${namedKeys.join(", ")}.` : null;
-    const reportEntry = (key, errors) => new PatchOutputFile(key, 0, [], "", "", "", errors);
-    const reportFiles = fileHunks.filter((g) => g.Key != "" && !fileContents.has(g.Key)).map((g) => reportEntry(g.Key, [new PatchError("FileMismatch", g.Hunks[0].ToUnanchoredChunk(), g.Key, rosterHint)]));
-    if (routingErrors.length > 0)
-      reportFiles.unshift(reportEntry("", routingErrors));
-    const reportErrors = reportFiles.flatMap((f) => f.Errors);
-    if (reportErrors.length > 0 && !options.ContinueOnError)
-      throw new PatchException(reportErrors[0]);
-    const patchOutputFiles = files.map((f) => {
-      const targetSelection = new SelectionTarget(f.InputFullText, f.InputSelectedText);
-      const targetText = targetSelection.TargetText;
-      const group = fileHunks.find((h) => h.Key == f.Key);
-      const hunks = group?.Hunks ?? [];
-      const contextOnly = group?.ContextOnlyHunkLines ?? [];
-      const anchored = HunkAnchorer.Anchor(targetText, hunks, options, contextOnly.length > 0);
-      const outputEdits = ChunkApplier.Apply(targetText, anchored.Chunks, options);
-      const contextDivergences = ContextAuditor.Audit(anchored.Chunks, TextUtils.ToLines(targetText)).map((d) => d.Shift(targetSelection.LineOffset));
-      const file = new PatchOutputFile(f.Key, outputEdits.Edits.map((h) => h.Fuzz).reduce((a, b) => a + b, 0), outputEdits.Edits.map((e) => e.Shift(targetSelection.LineOffset)), f.InputSelectedText, f.InputFullText, targetSelection.Replace(outputEdits.OutputText), [...outputEdits.Errors], anchored.AlreadyAppliedCount);
-      file.Notices = PatchNotices.For(hunks, file, contextOnly, contextDivergences);
-      return file;
-    });
-    return new PatchOutput([...patchOutputFiles, ...reportFiles]);
-  }
-};
-
-// cli/agents/pi/server/piPatcherExtension.ts
-var DESCRIPTION = true ? "Apply unified diffs to files \u2014 tolerant of form, strict about intent. Repairs sloppy AI-generated diffs (mangled headers, whitespace drift, missing prefixes; line numbers can be wrong or absent \u2014 hunks anchor by fuzzy-matched context lines) and applies all hunks atomically when the intent is unambiguous; fails with a precise, typed error when it isn't. Use for multi-hunk edits in one step, or when exact string-replacement editing fails on whitespace or invisible characters." : "Apply unified diffs to files.";
-var BUILD_TAG = true ? "matchu-patchu-pi 0.3.5, built 2026-08-03 10:40:13" : "matchu-patchu-pi dev";
-var errorBlocks = (errors) => {
-  const parts = [`Patch failed with ${errors.length} error(s):`];
-  for (const e of errors) parts.push("", e.toString());
-  return parts.join("\n");
-};
-var outcomeMessage = (target, out) => `Applied ${out.Edits.length} edit(s) to ${target}.` + (out.Edits.length > 0 ? "" : " File left unmodified.") + out.Notices.map((n) => " " + n).join("");
-function discoverDiffKeys(diff) {
-  const keys = [];
-  for (const f of Patcher.Apply(diff, []).Files) {
-    if (f.Key && !keys.includes(f.Key)) keys.push(f.Key);
-  }
-  return keys;
-}
-function applySingle(cwd, filePath, diff, dryRun) {
-  const abs = resolve(cwd, filePath);
-  if (!existsSync(abs)) return { ok: false, message: `Error: file not found: ${filePath}` };
-  const out = Patcher.Apply(diff, [new PatchInputFile("", readFileSync(abs, "utf-8"))]).Files[0];
-  if (out.Errors.length > 0) return { ok: false, message: errorBlocks(out.Errors) };
-  if (out.Edits.length > 0 && !dryRun) writeFileSync(abs, out.OutputFullText);
-  return {
-    ok: true,
-    message: outcomeMessage(filePath, out) + (dryRun ? `
-
---- patched output ---
-${out.OutputFullText}` : "")
-  };
-}
-function applyMulti(cwd, diff, dryRun) {
-  const keys = discoverDiffKeys(diff);
-  if (keys.length === 0)
-    return { ok: false, message: "Error: no file headers (---/+++) found in the diff \u2014 pass filePath to patch a headerless diff into one file" };
-  const missing = keys.filter((k) => !existsSync(resolve(cwd, k)));
-  if (missing.length > 0)
-    return { ok: false, message: missing.map((k) => `Error: file not found: ${k}`).join("\n") };
-  const inputs = keys.map((k) => new PatchInputFile(k, readFileSync(resolve(cwd, k), "utf-8")));
-  const result = Patcher.Apply(diff, inputs);
-  const errors = result.Files.flatMap((f) => f.Errors);
-  if (errors.length > 0) return { ok: false, message: errorBlocks(errors) };
-  const lines = [];
-  const dryOutputs = [];
-  for (const out of result.Files) {
-    if (out.Edits.length > 0) {
-      if (!dryRun) writeFileSync(resolve(cwd, out.Key), out.OutputFullText);
-      else dryOutputs.push(`--- patched output: ${out.Key} ---
-${out.OutputFullText}`);
-    }
-    lines.push(outcomeMessage(out.Key, out));
-  }
-  return { ok: true, message: [lines.join("\n"), ...dryOutputs].join("\n\n") };
-}
-function applyPatch(cwd, args) {
-  if (!args.diff || !args.diff.trim()) return { ok: false, message: "Error: patch is empty" };
-  try {
-    const out = args.filePath ? applySingle(cwd, args.filePath, args.diff, args.dryRun === true) : applyMulti(cwd, args.diff, args.dryRun === true);
-    return out.ok ? { ok: true, message: `${out.message} [${BUILD_TAG}]` } : out;
-  } catch (ex) {
-    if (ex instanceof PatchParserException)
-      return { ok: false, message: `Error: failed to parse patch \u2014 ${ex.message}` };
-    return { ok: false, message: `Error: ${ex instanceof Error ? ex.message : String(ex)}` };
-  }
-}
-function logErr(...a) {
-  try {
-    console.error("[matchu-patchu]", ...a);
-  } catch {
-  }
-}
-function patchOwnership(tools, registeredByUs) {
-  const patch = tools.find((t) => t.name === "patch");
-  if (!patch) return "absent";
-  return registeredByUs || /matchu-patchu/i.test(patch.sourceInfo?.path ?? "") ? "ours" : "foreign";
-}
-var PATCH_TOOL = {
-  name: "patch",
-  label: "Patch",
-  description: DESCRIPTION,
-  promptSnippet: "Modify one or more existing files by applying a unified diff",
-  promptGuidelines: [
-    "Use patch for every edit to an existing file; write is only for creating new files or full rewrites.",
-    "patch accepts lenient unified diffs: line numbers are optional and hunks anchor by context lines. One diff may target several files via ---/+++ headers; pass filePath instead for a headerless single-file diff."
-  ],
-  parameters: Type.Object({
-    diff: Type.String({ description: "Unified diff content to apply" }),
-    filePath: Type.Optional(Type.String({
-      description: "Path of the single file to patch (absolute or relative to the project root); the diff's headers are then ignored. Omit to target the file(s) named by the diff's ---/+++ headers."
-    })),
-    dryRun: Type.Optional(Type.Boolean({ description: "If true, return the patched content without writing to disk" }))
-  }),
-  async execute(_id, params, _signal, _onUpdate, ctx) {
-    const { ok, message } = applyPatch(ctx.cwd, params);
-    if (!ok) throw new Error(message);
-    return { content: [{ type: "text", text: message }], details: {} };
-  }
-};
-function piPatcherExtension_default(pi) {
-  let registeredPatch = false;
-  try {
-    pi.on("session_start", () => {
-      try {
-        const owner = patchOwnership(pi.getAllTools(), registeredPatch);
-        if (owner === "foreign") {
-          logErr('another extension already provides "patch" \u2014 typebulb patcher standing down (built-in edit kept)');
-          return;
-        }
-        if (owner === "absent") {
-          pi.registerTool(PATCH_TOOL);
-          registeredPatch = true;
-        }
-        const active = pi.getActiveTools();
-        if (active.includes("edit")) pi.setActiveTools(active.filter((n) => n !== "edit"));
-      } catch (e) {
-        logErr("session_start", e);
-      }
-    });
-  } catch (e) {
-    logErr("load", e);
-  }
-}
-export {
-  applyPatch,
-  piPatcherExtension_default as default,
-  discoverDiffKeys,
-  patchOwnership
-};