@hassangameryt/freeflow 0.7.2 → 0.8.0

package/pi-extension/dist/provider-support/openai/adapter.js

@@ -0,0 +1,127 @@
+import { assemble, EFFORTS } from "./history.js";
+import { SessionState } from "./session-state.js";
+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;
+  if (model.baseUrl !== undefined && typeof model.baseUrl !== "string") return;
+  const base = (model.baseUrl ?? (codex ? "https://chatgpt.com/backend-api" : "https://api.openai.com/v1")).replace(
+    /\/+$/,
+    "",
+  );
+  const allowed = codex
+    ? [
+        "https://chatgpt.com/backend-api",
+        "https://chatgpt.com/backend-api/codex",
+        "https://chatgpt.com/backend-api/codex/responses",
+      ]
+    : ["https://api.openai.com/v1"];
+  if (!allowed.includes(base)) return;
+  return `${model.provider}/${model.api}/${model.id}`;
+}
+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,
+    // 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++;
+    this.session = undefined;
+    this.compacting = false;
+    this.status(ctx, undefined);
+  }
+  setCompacting(value) {
+    this.compacting = value;
+  }
+  status(_ctx, label) {
+    if (this.statusSignature === label) return;
+    this.statusSignature = label;
+    // 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 () => {
+      // 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 (
+          typeof this.pi.appendEntry !== "function" ||
+          !reader?.getLeafId ||
+          !reader.getSessionId ||
+          !reader.getSessionFile
+        )
+          throw new Error("Native session persistence unavailable");
+        const id = reader.getSessionId(),
+          file = reader.getSessionFile();
+        if (!this.session || this.session.id !== id || this.session.file !== file)
+          this.session = { id, file, store: new SessionState(this.pi, reader) };
+        const store = this.session.store,
+          basis = reader.getLeafId();
+        const records = await store.records();
+        if (
+          generation !== this.generation ||
+          reader.getLeafId() !== basis ||
+          this.session?.store !== store ||
+          key !== requestKey(payload, ctx.model)
+        )
+          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, `${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, `${label} cache adaptation unavailable · native effort`);
+        return payload;
+      }
+    });
+    this.queue = operation.catch(() => {});
+    return operation;
+  }
+}

package/pi-extension/dist/provider-support/openai/history.js

@@ -0,0 +1,127 @@
+import { createHash, randomUUID } from "node:crypto";
+// 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);
+const effort = (x) => EFFORTS.includes(x);
+const identity = (x) => typeof x === "string" && x.length > 0 && x.length <= 1024;
+export function parseAttempt(value) {
+  if (
+    !value ||
+    value.version !== 1 ||
+    !identity(value.id) ||
+    !(value.basis === null || identity(value.basis)) ||
+    !identity(value.key) ||
+    !identity(value.generation) ||
+    !digest(value.envelope) ||
+    !digest(value.inputHash) ||
+    !effort(value.baseline) ||
+    !effort(value.effective) ||
+    !(value.parent === null || identity(value.parent)) ||
+    !Number.isSafeInteger(value.length) ||
+    value.length < 0 ||
+    (value.update !== undefined &&
+      (!value.update ||
+        !Number.isSafeInteger(value.update.at) ||
+        value.update.at < 0 ||
+        value.update.at > value.length ||
+        !digest(value.update.prefixHash) ||
+        !effort(value.update.effort))) ||
+    Object.keys(value).some(
+      (k) =>
+        ![
+          "version",
+          "id",
+          "basis",
+          "key",
+          "generation",
+          "envelope",
+          "baseline",
+          "effective",
+          "parent",
+          "length",
+          "inputHash",
+          "update",
+        ].includes(k),
+    )
+  )
+    throw new Error("Invalid OpenAI effort history");
+  return value;
+}
+// Hash complete serialized items, including opaque reasoning; never persist their bodies.
+export function prefixHashes(input) {
+  const result = [hash([])];
+  for (const item of input) result.push(hash([result.at(-1), item]));
+  return result;
+}
+export function envelopeHash(payload) {
+  const { input: _input, prompt_cache_key: _key, max_output_tokens: _max, stream: _stream, ...rest } = payload;
+  const { effort: _effort, ...reasoning } = rest.reasoning;
+  return hash({ ...rest, reasoning });
+}
+export function assemble(payload, key, generation, basis, records) {
+  const hashes = prefixHashes(payload.input),
+    envelope = envelopeHash(payload);
+  const applicable = records.filter((r) => r.key === key && r.generation === generation);
+  const compatible = applicable.filter((r) => r.envelope === envelope && hashes[r.length] === r.inputHash);
+  const prior = compatible.reduce((best, r) => (!best || r.length >= best.length ? r : best), undefined);
+  const baseline = prior?.baseline ?? applicable[0]?.baseline ?? payload.reasoning.effort;
+  const desired = payload.reasoning.effort;
+  const byId = new Map(records.map((r) => [r.id, r]));
+  const updates = [];
+  const seen = new Set();
+  let cursor = prior;
+  while (cursor) {
+    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("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("OpenAI effort history parent unavailable");
+    cursor = parent;
+  }
+  let update;
+  if (desired !== (prior?.effective ?? baseline)) {
+    // Only insert before a new user item. Within a tool loop, append after all completed exchanges.
+    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 OpenAI effort updates");
+    updates.push(update);
+  }
+  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;
+  for (let i = 0; i <= payload.input.length; i++) {
+    if (updates[nextUpdate]?.at === i) {
+      output.input.push({ type: "configuration_update", reasoning: { effort: updates[nextUpdate++].effort } });
+    }
+    if (i < payload.input.length) output.input.push(structuredClone(payload.input[i]));
+  }
+  output.reasoning.effort = baseline;
+  // Records mark baselines and effort changes; a longer input under the same effort needs none.
+  const identical = !!prior && !update;
+  const record = identical
+    ? undefined
+    : {
+        version: 1,
+        id: randomUUID(),
+        basis,
+        key,
+        generation,
+        envelope,
+        baseline,
+        effective: desired,
+        parent: prior?.id ?? null,
+        length: payload.input.length,
+        inputHash: hashes.at(-1),
+        ...(update ? { update } : {}),
+      };
+  return { payload: output, record, baseline, effective: desired, rebased: !prior && applicable.length > 0 };
+}

package/pi-extension/dist/provider-support/openai/index.js

@@ -0,0 +1,15 @@
+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));
+  pi.on("session_compact", (_event, ctx) => adapter.reset(ctx));
+  pi.on("session_compact_failed", () => adapter.setCompacting(false));
+  pi.on("before_provider_request", (event, ctx) => adapter.adapt(event.payload, ctx));
+}

package/pi-extension/dist/provider-support/openai/session-state.js

@@ -0,0 +1,105 @@
+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;
+  acknowledged = new Map();
+  fault;
+  constructor(pi, reader) {
+    this.pi = pi;
+    this.reader = reader;
+  }
+  branch() {
+    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 OpenAI effort session ancestry");
+      seen.add(entry.id);
+      parent = entry.id;
+    }
+    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 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",
+      earlierEpoch = "root";
+    for (const entry of branch) {
+      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) => {
+      const record = parseAttempt(e.data);
+      if (
+        record.basis !== e.parentId &&
+        !(this.reader.getHeader?.()?.parentSession && !branch.some((entry) => entry.id === record.basis))
+      )
+        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 OpenAI effort attempt");
+    const parents = new Map();
+    for (const record of records) {
+      const parent = record.parent === null ? undefined : parents.get(record.parent);
+      if (
+        record.parent !== null &&
+        (!parent ||
+          parent.key !== record.key ||
+          parent.generation !== record.generation ||
+          parent.envelope !== record.envelope ||
+          parent.baseline !== record.baseline ||
+          parent.length > record.length)
+      )
+        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 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 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;
+  }
+  generation() {
+    let generation = "root";
+    for (const entry of this.branch()) {
+      if (entry.type === "compaction") generation = entry.id;
+    }
+    return generation;
+  }
+  append(record) {
+    try {
+      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("OpenAI effort append not acknowledged");
+      this.acknowledged.set(entry.id, JSON.stringify(entry));
+    } catch (error) {
+      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;
+}