@hassangameryt/freeflow 0.7.3 → 0.8.0

package/pi-extension/dist/provider-support/{astra → openai}/adapter.js

@@ -1,22 +1,11 @@
 import { assemble, EFFORTS } from "./history.js";
 import { SessionState } from "./session-state.js";
-export function requestKey(payload, model) {
-  if (
-    !payload ||
-    payload.model !== "gpt-6-astra" ||
-    model?.id !== payload.model ||
-    payload.store !== false ||
-    !Array.isArray(payload.input) ||
-    !EFFORTS.includes(payload.reasoning?.effort) ||
-    payload.previous_response_id ||
-    payload.conversation ||
-    payload.context_management ||
-    (payload.truncation && payload.truncation !== "disabled") ||
-    (payload.reasoning.mode && payload.reasoning.mode !== "standard") ||
-    payload.agents ||
-    payload.input.some((x) => x?.type === "configuration_update" || x?.type === "compaction_trigger")
-  )
-    return;
+import { isChatGPTSignIn } from "../routes.js";
+// Only these qualified official routes receive effort-history adaptation; keys isolate models.
+const SUPPORTED_MODELS = new Set(["gpt-6-astra", "gpt-6-luna", "gpt-6-sol"]);
+/** The effort-history key for a qualified official GPT-6 route, or undefined when the route is not supported. */
+export function effortHistoryRoute(model) {
+  if (!model || !SUPPORTED_MODELS.has(model.id)) return;
   const codex = model.provider === "openai-codex" && model.api === "openai-codex-responses";
   const api = model.provider === "openai" && model.api === "openai-responses";
   if (!codex && !api) return;
@@ -35,15 +24,43 @@ export function requestKey(payload, model) {
   if (!allowed.includes(base)) return;
   return `${model.provider}/${model.api}/${model.id}`;
 }
-export class AstraAdapter {
+export function requestKey(payload, model) {
+  if (
+    !payload ||
+    !SUPPORTED_MODELS.has(payload.model) ||
+    model?.id !== payload.model ||
+    payload.store !== false ||
+    !Array.isArray(payload.input) ||
+    !EFFORTS.includes(payload.reasoning?.effort) ||
+    payload.previous_response_id ||
+    payload.conversation ||
+    payload.context_management ||
+    (payload.truncation && payload.truncation !== "disabled") ||
+    (payload.reasoning.mode && payload.reasoning.mode !== "standard") ||
+    payload.agents ||
+    payload.input.some((x) => x?.type === "configuration_update" || x?.type === "compaction_trigger")
+  )
+    return;
+  return effortHistoryRoute(model);
+}
+export class OpenAIEffortAdapter {
   pi;
+  enabled;
+  monitor;
   session;
   generation = 0;
   compacting = false;
   queue = Promise.resolve();
   statusSignature;
-  constructor(pi) {
+  constructor(
+    pi,
+    // Global Freeflow disablement leaves provider requests and session history untouched.
+    enabled = () => true,
+    monitor,
+  ) {
     this.pi = pi;
+    this.enabled = enabled;
+    this.monitor = monitor;
   }
   reset(ctx) {
     this.generation++;
@@ -54,22 +71,22 @@ export class AstraAdapter {
   setCompacting(value) {
     this.compacting = value;
   }
-  status(ctx, label) {
+  status(_ctx, label) {
     if (this.statusSignature === label) return;
     this.statusSignature = label;
-    // Diagnostics must never turn a completed payload transformation into an exception.
-    try {
-      ctx.ui?.setStatus?.("freeflow-astra-effort", label);
-    } catch {}
+    // A cache diagnostic, reported to /freeflow status rather than the settings footer.
+    this.monitor?.set("openai-effort", label);
   }
   async adapt(payload, ctx) {
     const generation = this.generation;
     const operation = this.queue.then(async () => {
-      const key = requestKey(payload, ctx.model);
-      if (generation !== this.generation || this.compacting || !key) {
+      // Sign in with ChatGPT rejects configuration_update items (live, 400), so effort history cannot apply.
+      const key = isChatGPTSignIn(ctx.model, ctx) ? undefined : requestKey(payload, ctx.model);
+      if (generation !== this.generation || this.compacting || !key || !this.enabled()) {
         this.status(ctx, undefined);
         return payload;
       }
+      const label = ctx.model.id === "gpt-6-astra" ? "Astra" : ctx.model.id;
       try {
         const reader = ctx.sessionManager;
         if (
@@ -92,15 +109,15 @@ export class AstraAdapter {
           this.session?.store !== store ||
           key !== requestKey(payload, ctx.model)
         )
-          throw new Error("Astra request changed during preparation");
+          throw new Error("OpenAI effort request changed during preparation");
         const result = assemble(payload, key, store.generation(), basis, records);
         if (result.record) store.append(result.record);
-        this.status(ctx, `Astra ${result.effective} · cache baseline ${result.baseline}`);
+        this.status(ctx, `${label} ${result.effective} · cache baseline ${result.baseline}`);
         return result.payload;
       } catch {
         // Pi swallows hook exceptions. Return the untouched full-history request,
         // including its requested effort, instead of a partially pinned request.
-        this.status(ctx, "Astra cache adaptation unavailable · native effort");
+        this.status(ctx, `${label} cache adaptation unavailable · native effort`);
         return payload;
       }
     });

package/pi-extension/dist/provider-support/{astra → openai}/history.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
-export const ENTRY_TYPE = "freeflow-astra-effort-v1";
+// This namespace starts a fresh effort chain; old Astra entries are deliberately ignored.
+export const ENTRY_TYPE = "freeflow-openai-effort-v1";
 export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 export const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const digest = (x) => typeof x === "string" && /^[a-f0-9]{64}$/.test(x);
@@ -45,7 +46,7 @@ export function parseAttempt(value) {
         ].includes(k),
     )
   )
-    throw new Error("Invalid Astra effort history");
+    throw new Error("Invalid OpenAI effort history");
   return value;
 }
 // Hash complete serialized items, including opaque reasoning; never persist their bodies.
@@ -72,16 +73,16 @@ export function assemble(payload, key, generation, basis, records) {
   const seen = new Set();
   let cursor = prior;
   while (cursor) {
-    if (seen.has(cursor.id)) throw new Error("Cyclic Astra history");
+    if (seen.has(cursor.id)) throw new Error("Cyclic OpenAI effort history");
     seen.add(cursor.id);
     if (cursor.update) {
-      if (hashes[cursor.update.at] !== cursor.update.prefixHash) throw new Error("Astra anchor changed");
+      if (hashes[cursor.update.at] !== cursor.update.prefixHash) throw new Error("OpenAI effort anchor changed");
       updates.unshift(cursor.update);
     }
     if (cursor.parent === null) break;
     const parent = byId.get(cursor.parent);
     if (!parent || parent.key !== key || parent.generation !== generation || parent.baseline !== baseline)
-      throw new Error("Astra history parent unavailable");
+      throw new Error("OpenAI effort history parent unavailable");
     cursor = parent;
   }
   let update;
@@ -90,10 +91,10 @@ export function assemble(payload, key, generation, basis, records) {
     const last = payload.input.length - 1;
     const at = payload.input[last]?.role === "user" && last >= (prior?.length ?? 0) ? last : payload.input.length;
     update = { at, prefixHash: hashes[at], effort: desired };
-    if (updates.at(-1)?.at === at) throw new Error("Adjacent Astra effort updates");
+    if (updates.at(-1)?.at === at) throw new Error("Adjacent OpenAI effort updates");
     updates.push(update);
   }
-  if (updates.some((u, i) => i > 0 && u.at <= updates[i - 1].at)) throw new Error("Invalid Astra update order");
+  if (updates.some((u, i) => i > 0 && u.at <= updates[i - 1].at)) throw new Error("Invalid OpenAI effort update order");
   const output = structuredClone(payload);
   output.input = [];
   let nextUpdate = 0;
@@ -104,7 +105,8 @@ export function assemble(payload, key, generation, basis, records) {
     if (i < payload.input.length) output.input.push(structuredClone(payload.input[i]));
   }
   output.reasoning.effort = baseline;
-  const identical = prior?.length === payload.input.length && prior.effective === desired;
+  // Records mark baselines and effort changes; a longer input under the same effort needs none.
+  const identical = !!prior && !update;
   const record = identical
     ? undefined
     : {

package/pi-extension/dist/provider-support/{astra → openai}/index.js

@@ -1,7 +1,11 @@
-import { AstraAdapter } from "./adapter.js";
-export function registerAstraSupport(pi) {
-  const adapter = new AstraAdapter(pi);
-  pi.on("session_start", (_event, ctx) => adapter.reset(ctx));
+import { OpenAIEffortAdapter } from "./adapter.js";
+import { trustStartedSession } from "../../host/read-only-session.js";
+export function registerOpenAIEffortSupport(pi, enabled, monitor) {
+  const adapter = new OpenAIEffortAdapter(pi, enabled, monitor);
+  pi.on("session_start", (event, ctx) => {
+    trustStartedSession(event?.reason, ctx.sessionManager);
+    adapter.reset(ctx);
+  });
   pi.on("session_shutdown", (_event, ctx) => adapter.reset(ctx));
   pi.on("session_tree", (_event, ctx) => adapter.reset(ctx));
   pi.on("session_before_compact", () => adapter.setCompacting(true));

package/pi-extension/dist/provider-support/{astra → openai}/session-state.js

@@ -1,5 +1,6 @@
-import { activeReadOnlySessionBranch, readOnlySessionSnapshot } from "../../session-sources/read-only-session.js";
+import { persistedBranchMatches } from "../../host/read-only-session.js";
 import { ENTRY_TYPE, parseAttempt } from "./history.js";
+import { cachedBranch } from "../../host/branch.js";
 export class SessionState {
   pi;
   reader;
@@ -10,35 +11,33 @@ export class SessionState {
     this.reader = reader;
   }
   branch() {
-    const entries = this.reader.getBranch();
+    const entries = cachedBranch(this.reader);
     let parent = null;
     const seen = new Set();
     for (const entry of entries) {
       if (!entry.id || seen.has(entry.id) || entry.parentId !== parent)
-        throw new Error("Invalid Astra session ancestry");
+        throw new Error("Invalid OpenAI effort session ancestry");
       seen.add(entry.id);
       parent = entry.id;
     }
-    if (parent !== this.reader.getLeafId()) throw new Error("Astra session leaf changed");
+    if (parent !== this.reader.getLeafId()) throw new Error("OpenAI effort session leaf changed");
     return entries;
   }
   async records() {
     if (this.fault) throw new Error(this.fault);
     const branch = this.branch();
-    // Model visits are not history replacement. Derive both identities from the
-    // selected native ancestry so old v1 records remain readable without rewriting them.
-    const boundaries = new Map();
+    // Model visits and branch summaries preserve compatible history; compaction does not. A branch summary
+    // follows its branch point, leaving the path before it unchanged. Records written while branch summaries
+    // still started a generation carry that earlier boundary and stay readable.
+    const boundaries = new Map(),
+      earlier = new Map();
     let epoch = "root",
-      legacy = "root",
-      model;
+      earlierEpoch = "root";
     for (const entry of branch) {
-      if (entry.type === "compaction" || entry.type === "branch_summary") epoch = legacy = entry.id;
-      if (entry.type === "model_change") {
-        const next = `${entry.provider}/${entry.modelId}`;
-        if (model !== next) legacy = entry.id;
-        model = next;
-      }
-      boundaries.set(entry.id, { epoch, legacy });
+      if (entry.type === "compaction") epoch = entry.id;
+      if (entry.type === "compaction" || entry.type === "branch_summary") earlierEpoch = entry.id;
+      boundaries.set(entry.id, epoch);
+      earlier.set(entry.id, earlierEpoch);
     }
     const entries = branch.filter((e) => e.type === "custom" && e.customType === ENTRY_TYPE);
     const records = entries.map((e) => {
@@ -47,13 +46,12 @@ export class SessionState {
         record.basis !== e.parentId &&
         !(this.reader.getHeader?.()?.parentSession && !branch.some((entry) => entry.id === record.basis))
       )
-        throw new Error("Astra attempt anchor mismatch");
-      const boundary = boundaries.get(e.id);
-      if (record.generation !== boundary.epoch && record.generation !== boundary.legacy)
-        throw new Error("Astra history generation unavailable");
-      return { ...record, generation: boundary.epoch };
+        throw new Error("OpenAI effort attempt anchor mismatch");
+      if (record.generation !== boundaries.get(e.id) && record.generation !== earlier.get(e.id))
+        throw new Error("OpenAI effort history generation unavailable");
+      return record;
     });
-    if (new Set(records.map((r) => r.id)).size !== records.length) throw new Error("Duplicate Astra attempt");
+    if (new Set(records.map((r) => r.id)).size !== records.length) throw new Error("Duplicate OpenAI effort attempt");
     const parents = new Map();
     for (const record of records) {
       const parent = record.parent === null ? undefined : parents.get(record.parent);
@@ -66,25 +64,18 @@ export class SessionState {
           parent.baseline !== record.baseline ||
           parent.length > record.length)
       )
-        throw new Error("Invalid Astra history parent");
+        throw new Error("Invalid OpenAI effort history parent");
       const expected = record.update?.effort ?? parent?.effective ?? record.baseline;
       if (record.effective !== expected || (record.update && record.update.at < (parent?.length ?? 0)))
-        throw new Error("Invalid Astra effective effort");
+        throw new Error("Invalid OpenAI effective effort");
       parents.set(record.id, record);
     }
     const unknown = entries.some((e) => this.acknowledged.get(e.id) !== JSON.stringify(e));
     const file = this.reader.getSessionFile();
     if (unknown && file && branch.some((e) => e.type === "message" && e.message?.role === "assistant")) {
-      const sessionId = this.reader.getSessionId(),
-        leaf = this.reader.getLeafId();
-      const snapshot = await readOnlySessionSnapshot(file);
-      const persisted = activeReadOnlySessionBranch(snapshot, leaf);
-      if (
-        snapshot.sessionId !== sessionId ||
-        this.reader.getLeafId() !== leaf ||
-        JSON.stringify(persisted) !== JSON.stringify(branch)
-      )
-        throw new Error("Astra persisted ancestry differs");
+      const leaf = this.reader.getLeafId();
+      if (!(await persistedBranchMatches(this.reader, leaf, branch)) || this.reader.getLeafId() !== leaf)
+        throw new Error("OpenAI effort persisted ancestry differs");
     }
     for (const entry of entries) this.acknowledged.set(entry.id, JSON.stringify(entry));
     return records;
@@ -92,22 +83,22 @@ export class SessionState {
   generation() {
     let generation = "root";
     for (const entry of this.branch()) {
-      if (entry.type === "compaction" || entry.type === "branch_summary") generation = entry.id;
+      if (entry.type === "compaction") generation = entry.id;
     }
     return generation;
   }
   append(record) {
     try {
-      if (this.reader.getLeafId() !== record.basis) throw new Error("Astra request ancestry changed");
+      if (this.reader.getLeafId() !== record.basis) throw new Error("OpenAI effort request ancestry changed");
       this.pi.appendEntry(ENTRY_TYPE, record);
       const entry = this.branch().find(
         (e) => e.type === "custom" && e.customType === ENTRY_TYPE && e.data?.id === record.id,
       );
       if (!entry || entry.parentId !== record.basis || JSON.stringify(entry.data) !== JSON.stringify(record))
-        throw new Error("Astra append not acknowledged");
+        throw new Error("OpenAI effort append not acknowledged");
       this.acknowledged.set(entry.id, JSON.stringify(entry));
     } catch (error) {
-      this.fault = "Astra append uncertain; native effort retained until session recovery";
+      this.fault = "OpenAI effort append uncertain; native effort retained until session recovery";
       throw error;
     }
   }

package/pi-extension/dist/provider-support/routes.js

@@ -0,0 +1,17 @@
+const OPENAI_API = "https://api.openai.com/v1";
+/**
+ * OpenAI's Sign in with ChatGPT (Pi 0.99): the openai provider's Responses API at api.openai.com with a ChatGPT
+ * credential instead of an API key. It reaches the ChatGPT backend. Live on gpt-6-luna and gpt-6.1-sol (2026-09-30) it
+ * rejected prompt_cache_breakpoint, max_output_tokens and configuration_update items with HTTP 400, and reused the
+ * whole cached prefix after 25 appended message endings without breakpoints. Freeflow sends its requests as Pi
+ * built them.
+ */
+export function isChatGPTSignIn(model, ctx) {
+  if (model?.provider !== "openai" || model.api !== "openai-responses") return false;
+  if ((model.baseUrl ?? OPENAI_API).replace(/\/+$/, "") !== OPENAI_API) return false;
+  try {
+    return ctx?.modelRegistry?.isUsingOAuth?.(model) === true;
+  } catch {
+    return false;
+  }
+}

package/pi-extension/dist/tool-execution/apply-patch/grammar.js

@@ -0,0 +1,23 @@
+// The apply_patch Lark grammar from OpenAI Codex (codex-rs/core/assets/tools/apply_patch.lark at bcd6d9ab),
+// Copyright 2025 OpenAI, licensed under the Apache License 2.0 (https://www.apache.org/licenses/LICENSE-2.0).
+// GPT models are trained on this exact grammar; keep it byte-identical to upstream.
+export const APPLY_PATCH_LARK_GRAMMAR = `start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change_move? change?
+
+filename: /(.+)/
+add_line: "+" /(.*)/ LF -> line
+
+change_move: "*** Move to: " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+
+%import common.LF
+`;

package/pi-extension/dist/tool-execution/apply-patch/match.js

@@ -0,0 +1,38 @@
+// Locating a hunk's lines in a file, with the four passes of OpenAI Codex's seek_sequence
+// (codex-rs/apply-patch/src/seek_sequence.rs at bcd6d9ab, Apache-2.0): exact, then ignoring trailing whitespace,
+// then ignoring surrounding whitespace, then after normalizing Unicode punctuation and spaces.
+function normalise(line) {
+  return line
+    .trim()
+    .replace(/[‐‑‒–—―−]/g, "-")
+    .replace(/[‘’‚‛]/g, "'")
+    .replace(/[“”„‟]/g, '"')
+    .replace(/[  -   　]/g, " ");
+}
+const PASSES = [(line) => line, (line) => line.trimEnd(), (line) => line.trim(), normalise];
+function matchesAt(lines, pattern, at, pass) {
+  const compare = PASSES[pass];
+  for (let i = 0; i < pattern.length; i++) if (compare(lines[at + i]) !== compare(pattern[i])) return false;
+  return true;
+}
+/**
+ * The first index at or after `start` where `pattern` matches, and the pass that matched. With `endOfFile`, the
+ * search starts where the pattern would end the file (falling back to `start` when that is earlier than the file).
+ */
+export function seekSequence(lines, pattern, start, endOfFile) {
+  if (pattern.length === 0) return { index: start, pass: 0 };
+  if (pattern.length > lines.length) return undefined;
+  const from = endOfFile ? Math.max(lines.length - pattern.length, start) : start;
+  for (let pass = 0; pass < PASSES.length; pass++)
+    for (let i = from; i <= lines.length - pattern.length; i++)
+      if (matchesAt(lines, pattern, i, pass)) return { index: i, pass };
+  return undefined;
+}
+/** Other places in the whole file where the pattern matches with the same pass: a visible sign of ambiguity. */
+export function otherMatches(lines, pattern, index, pass) {
+  if (pattern.length === 0) return [];
+  const found = [];
+  for (let i = 0; i <= lines.length - pattern.length; i++)
+    if (i !== index && matchesAt(lines, pattern, i, pass)) found.push(i);
+  return found;
+}

package/pi-extension/dist/tool-execution/apply-patch/parser.js

@@ -0,0 +1,177 @@
+// A port of OpenAI Codex's apply_patch parser (codex-rs/apply-patch/src/{parser,streaming_parser}.rs at bcd6d9ab,
+// Apache-2.0), including its lenient forms, so patches GPT models write for Codex parse the same way here.
+export class PatchParseError extends Error {
+  line;
+  constructor(message, line) {
+    super(line === undefined ? message : `${message} (patch line ${line})`);
+    this.line = line;
+  }
+}
+const BEGIN = "*** Begin Patch";
+const END = "*** End Patch";
+const ADD = "*** Add File: ";
+const DELETE = "*** Delete File: ";
+const UPDATE = "*** Update File: ";
+const MOVE = "*** Move to: ";
+const EOF_MARKER = "*** End of File";
+const ENVIRONMENT = "*** Environment ID: ";
+const HEADERS = "Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'";
+const UNEXPECTED = (line) =>
+  `Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`;
+function boundaries(lines) {
+  const strict = (candidate) => {
+    const first = candidate[0]?.trim(),
+      last = candidate.at(-1)?.trim();
+    if (first !== BEGIN) throw new PatchParseError(`The first line of the patch must be '${BEGIN}'`);
+    if (last !== END) throw new PatchParseError(`The last line of the patch must be '${END}'`);
+    return candidate;
+  };
+  try {
+    return strict(lines);
+  } catch (error) {
+    // Codex's lenient mode: a heredoc wrapper, as GPT models write for a shell invocation. The optional
+    // `apply_patch` prefix covers the same wrapper copied from a shell command.
+    const first = lines[0]?.replace(/^apply_patch\s+/, "");
+    if (["<<EOF", "<<'EOF'", '<<"EOF"'].includes(first ?? "") && lines.at(-1)?.endsWith("EOF") && lines.length >= 4)
+      return strict(lines.slice(1, -1));
+    throw error;
+  }
+}
+export function parsePatch(text) {
+  const lines = boundaries(text.trim().split(/\r?\n/));
+  const hunks = [];
+  let mode = "started";
+  let updateHeaderLine = 0;
+  let environment = false;
+  const lastUpdate = () => {
+    const hunk = hunks.at(-1);
+    return hunk?.kind === "update" ? hunk : undefined;
+  };
+  const ensureUpdateNotEmpty = (line, number) => {
+    const update = mode === "update" ? lastUpdate() : undefined;
+    if (!update) return;
+    if (update.chunks.length === 0)
+      throw new PatchParseError(`Update file hunk for path '${update.path}' is empty`, updateHeaderLine);
+    const chunk = update.chunks.at(-1);
+    if (chunk.oldLines.length === 0 && chunk.newLines.length === 0)
+      throw new PatchParseError(line === END ? "Update hunk does not contain any lines" : UNEXPECTED(line), number);
+  };
+  const header = (trimmed, number) => {
+    if (mode === "started" && trimmed.startsWith(ENVIRONMENT) && hunks.length === 0) {
+      if (environment) throw new PatchParseError("apply_patch environment_id cannot be specified more than once");
+      if (!trimmed.slice(ENVIRONMENT.length).trim())
+        throw new PatchParseError("apply_patch environment_id cannot be empty");
+      environment = true;
+      return true;
+    }
+    for (const [marker, kind] of [
+      [END, "end"],
+      [ADD, "add"],
+      [DELETE, "delete"],
+      [UPDATE, "update"],
+    ]) {
+      if (kind === "end" ? trimmed !== END : !trimmed.startsWith(marker)) continue;
+      ensureUpdateNotEmpty(trimmed, number);
+      const path = trimmed.slice(marker.length);
+      if (kind === "end") mode = "ended";
+      else if (kind === "add") {
+        hunks.push({ kind: "add", path, contents: "" });
+        mode = "add";
+      } else if (kind === "delete") {
+        hunks.push({ kind: "delete", path });
+        mode = "delete";
+      } else {
+        hunks.push({ kind: "update", path, chunks: [] });
+        mode = "update";
+        updateHeaderLine = number;
+      }
+      return true;
+    }
+    return false;
+  };
+  const chunk = (update) => {
+    if (update.chunks.length === 0) update.chunks.push({ oldLines: [], newLines: [], context: [], endOfFile: false });
+    return update.chunks.at(-1);
+  };
+  lines.slice(1).forEach((line, offset) => {
+    const number = offset + 2;
+    const trimmed = line.trim();
+    if (mode === "ended") {
+      if (trimmed) throw new PatchParseError(`The last line of the patch must be '${END}'`, number);
+      return;
+    }
+    if (mode === "started") {
+      if (!header(trimmed, number))
+        throw new PatchParseError(`'${trimmed}' is not a valid hunk header. ${HEADERS}`, number);
+      return;
+    }
+    if (mode === "add") {
+      if (header(trimmed, number)) return;
+      const add = hunks.at(-1);
+      if (line.startsWith("+") && add?.kind === "add") {
+        add.contents += `${line.slice(1)}\n`;
+        return;
+      }
+      throw new PatchParseError(`'${trimmed}' is not a valid hunk header. ${HEADERS}`, number);
+    }
+    if (mode === "delete") {
+      if (header(trimmed, number)) return;
+      throw new PatchParseError(`'${trimmed}' is not a valid hunk header. ${HEADERS}`, number);
+    }
+    // Update file.
+    const updateLine = line.trimEnd();
+    if (header(updateLine, number)) return;
+    const update = lastUpdate();
+    const current = update.chunks.at(-1);
+    if (current?.endOfFile) {
+      if (!updateLine) return;
+      if (updateLine !== "@@" && !updateLine.startsWith("@@ "))
+        throw new PatchParseError(`Expected update hunk to start with a @@ context marker, got: '${line}'`, number);
+    }
+    if (update.chunks.length === 0 && update.moveTo === undefined && updateLine.startsWith(MOVE)) {
+      update.moveTo = updateLine.slice(MOVE.length);
+      return;
+    }
+    const isAnchor = updateLine === "@@" || updateLine.startsWith("@@ ");
+    if (isAnchor && current && current.oldLines.length === 0 && current.newLines.length === 0)
+      throw new PatchParseError(UNEXPECTED(line), number);
+    if (isAnchor) {
+      update.chunks.push({
+        ...(updateLine === "@@" ? {} : { anchor: updateLine.slice(3) }),
+        oldLines: [],
+        newLines: [],
+        context: [],
+        endOfFile: false,
+      });
+      return;
+    }
+    if (updateLine === EOF_MARKER) {
+      if (!current || (current.oldLines.length === 0 && current.newLines.length === 0))
+        throw new PatchParseError("Update hunk does not contain any lines", number);
+      current.endOfFile = true;
+      return;
+    }
+    if (line === "" || line.startsWith(" ")) {
+      const target = chunk(update);
+      target.context.push([target.oldLines.length, target.newLines.length]);
+      const text = line === "" ? "" : line.slice(1);
+      target.oldLines.push(text);
+      target.newLines.push(text);
+      return;
+    }
+    if (line.startsWith("+")) {
+      chunk(update).newLines.push(line.slice(1));
+      return;
+    }
+    if (line.startsWith("-")) {
+      chunk(update).oldLines.push(line.slice(1));
+      return;
+    }
+    if (current && (current.oldLines.length > 0 || current.newLines.length > 0))
+      throw new PatchParseError(`Expected update hunk to start with a @@ context marker, got: '${line}'`, number);
+    throw new PatchParseError(UNEXPECTED(line), number);
+  });
+  // `mode` changes inside the callback above, which the compiler cannot see.
+  if (mode !== "ended") throw new PatchParseError(`The last line of the patch must be '${END}'`);
+  return hunks;
+}