deepseek-web-retrieval 0.3.0 → 0.5.0

package/src/installer/formats/json.ts

@@ -1,35 +1,35 @@
-import { existsSync, readFileSync } from "node:fs"
-import { applyEdits, modify, parse, type JSONPath } from "jsonc-parser/lib/esm/main.js"
-import { parseJsonc } from "../../core/jsonc"
-import type { ConfigOp, RecordedOp } from "../types"
-import type { AppliedText, FormatCodec, LoadedConfig } from "./index"
-import { appendEntries, deepEqual, isPlainObject, valueAt } from "./value"
+import { existsSync, readFileSync } from "node:fs";
+import { applyEdits, type JSONPath, modify, parse } from "jsonc-parser/lib/esm/main.js";
+import { parseJsonc } from "../../core/jsonc";
+import type { ConfigOp, RecordedOp } from "../types";
+import type { AppliedText, FormatCodec, LoadedConfig } from "./index";
+import { appendEntries, deepEqual, isPlainObject, valueAt } from "./value";
 
-const JSON_FORMATTING = { insertSpaces: true, tabSize: 2, insertFinalNewline: false } as const
+const JSON_FORMATTING = { insertSpaces: true, tabSize: 2, insertFinalNewline: false } as const;
 
 /** Reads a JSONC config file; a missing file starts empty, an unparsable one carries the error. */
 function loadJson(file: string): LoadedConfig {
-  if (!existsSync(file)) return { exists: false, text: "", value: {}, lossy: false }
-  const text = readFileSync(file, "utf8")
+  if (!existsSync(file)) return { exists: false, text: "", value: {}, lossy: false };
+  const text = readFileSync(file, "utf8");
   try {
-    return { exists: true, text, value: parseJsonc(text) as Record<string, unknown>, lossy: false }
+    return { exists: true, text, value: parseJsonc(text) as Record<string, unknown>, lossy: false };
   } catch (error) {
-    const parseError = error instanceof Error ? error.message : String(error)
-    return { exists: true, text, value: {}, lossy: false, parseError }
+    const parseError = error instanceof Error ? error.message : String(error);
+    return { exists: true, text, value: {}, lossy: false, parseError };
   }
 }
 
 /** Reads the value at a dotted path from JSON text, or undefined when absent. */
 function jsonGet(text: string, path: readonly string[]): unknown {
-  const root = parse(text, undefined, { allowTrailingComma: true }) as Record<string, unknown>
-  return valueAt(root, path)
+  const root = parse(text, undefined, { allowTrailingComma: true }) as Record<string, unknown>;
+  return valueAt(root, path);
 }
 
 export interface JsonOpsResult {
-  readonly text: string
-  readonly recorded: RecordedOp[]
+  readonly text: string;
+  readonly recorded: RecordedOp[];
   /** Path prefixes the ops had to create; uninstall removes them when left empty. */
-  readonly createdParents: readonly (readonly string[])[]
+  readonly createdParents: readonly (readonly string[])[];
 }
 
 /**
@@ -39,97 +39,101 @@ export interface JsonOpsResult {
  * for surgical undo.
  */
 export function applyJsonOps(text: string, ops: readonly ConfigOp[]): JsonOpsResult {
-  let current = text.trim().length > 0 ? text : "{}\n"
-  const recorded: RecordedOp[] = []
-  const createdParents: (readonly string[])[] = []
+  let current = text.trim().length > 0 ? text : "{}\n";
+  const recorded: RecordedOp[] = [];
+  const createdParents: (readonly string[])[] = [];
   for (const op of ops) {
-    const path = op.path as unknown as JSONPath
+    const path = op.path as unknown as JSONPath;
     if (op.op === "set") {
-      current = ensureParents(current, op.path, createdParents)
-      const previous = jsonGet(current, op.path)
-      current = edit(current, path, op.value)
-      recorded.push({ op: "set", path: op.path, applied: structuredClone(op.value), previous })
-      continue
+      current = ensureParents(current, op.path, createdParents);
+      const previous = jsonGet(current, op.path);
+      current = edit(current, path, op.value);
+      recorded.push({ op: "set", path: op.path, applied: structuredClone(op.value), previous });
+      continue;
     }
-    current = ensureParents(current, op.path, createdParents)
-    const existing = jsonGet(current, op.path)
-    const { list, appended } = appendEntries(existing, op.entries ?? [], op.path)
+    current = ensureParents(current, op.path, createdParents);
+    const existing = jsonGet(current, op.path);
+    const { list, appended } = appendEntries(existing, op.entries ?? [], op.path);
     if (existing === undefined) {
-      current = edit(current, path, [])
-      createdParents.push(op.path)
+      current = edit(current, path, []);
+      createdParents.push(op.path);
     }
-    let index = list.length
+    let index = list.length;
     for (const entry of appended) {
-      current = edit(current, [...path, index] as unknown as JSONPath, entry)
-      index += 1
+      current = edit(current, [...path, index] as unknown as JSONPath, entry);
+      index += 1;
     }
-    recorded.push({ op: "append-array", path: op.path, applied: appended, previous: undefined })
+    recorded.push({ op: "append-array", path: op.path, applied: appended, previous: undefined });
   }
-  return { text: current, recorded, createdParents }
+  return { text: current, recorded, createdParents };
 }
 
 /** Reverses recorded ops on current JSON text; returns the text plus notes about skipped work. */
-export function revertJsonOps(text: string, ops: readonly RecordedOp[], createdParents: readonly (readonly string[])[]): { text: string; notes: string[] } {
-  let current = text
-  const notes: string[] = []
+export function revertJsonOps(
+  text: string,
+  ops: readonly RecordedOp[],
+  createdParents: readonly (readonly string[])[],
+): { text: string; notes: string[] } {
+  let current = text;
+  const notes: string[] = [];
   for (const record of [...ops].reverse()) {
-    const path = record.path as unknown as JSONPath
+    const path = record.path as unknown as JSONPath;
     if (record.op === "set") {
-      const now = jsonGet(current, record.path)
-      if (now === undefined) continue
+      const now = jsonGet(current, record.path);
+      if (now === undefined) continue;
       if (!deepEqual(now, record.applied)) {
-        notes.push(`${record.path.join(".")}: current value differs from what the installer wrote; left untouched`)
-        continue
+        notes.push(`${record.path.join(".")}: current value differs from what the installer wrote; left untouched`);
+        continue;
       }
-      current = record.previous === undefined ? edit(current, path, void 0) : edit(current, path, record.previous)
+      current = record.previous === undefined ? edit(current, path, void 0) : edit(current, path, record.previous);
     } else {
-      const entries = Array.isArray(record.applied) ? record.applied : []
+      const entries = Array.isArray(record.applied) ? record.applied : [];
       for (const entry of [...entries].reverse()) {
-        const list = jsonGet(current, record.path)
-        if (!Array.isArray(list)) continue
-        const index = list.findIndex((item) => deepEqual(item, entry))
-        if (index === -1) continue
-        current = edit(current, [...path, index] as unknown as JSONPath, void 0)
+        const list = jsonGet(current, record.path);
+        if (!Array.isArray(list)) continue;
+        const index = list.findIndex((item) => deepEqual(item, entry));
+        if (index === -1) continue;
+        current = edit(current, [...path, index] as unknown as JSONPath, void 0);
       }
     }
   }
   for (const parent of [...createdParents].reverse()) {
-    const value = jsonGet(current, parent)
-    const isEmptyObject = isPlainObject(value) && Object.keys(value).length === 0
-    const isEmptyArray = Array.isArray(value) && value.length === 0
+    const value = jsonGet(current, parent);
+    const isEmptyObject = isPlainObject(value) && Object.keys(value).length === 0;
+    const isEmptyArray = Array.isArray(value) && value.length === 0;
     if (isEmptyObject || isEmptyArray) {
-      current = edit(current, parent as unknown as JSONPath, void 0)
+      current = edit(current, parent as unknown as JSONPath, void 0);
     }
   }
-  return { text: current, notes }
+  return { text: current, notes };
 }
 
 function edit(text: string, path: JSONPath, value: unknown): string {
-  return applyEdits(text, modify(text, path, value as never, { formattingOptions: JSON_FORMATTING }))
+  return applyEdits(text, modify(text, path, value as never, { formattingOptions: JSON_FORMATTING }));
 }
 
 /** Creates missing path prefixes as objects (or arrays when the next segment is an index). */
 function ensureParents(text: string, path: readonly string[], created: (readonly string[])[]): string {
-  let current = text
+  let current = text;
   for (let depth = 0; depth < path.length - 1; depth += 1) {
-    const prefix = path.slice(0, depth + 1)
-    const existing = jsonGet(current, prefix)
+    const prefix = path.slice(0, depth + 1);
+    const existing = jsonGet(current, prefix);
     if (existing !== undefined && typeof existing !== "object") {
-      throw new Error(`cannot descend into ${prefix.join(".")}: it is a ${typeof existing}, not an object`)
+      throw new Error(`cannot descend into ${prefix.join(".")}: it is a ${typeof existing}, not an object`);
     }
-    if (existing !== undefined) continue
-    const nextSegmentIsIndex = Number.isInteger(Number(path[depth + 1]))
-    const placeholder = nextSegmentIsIndex ? [] : {}
-    current = edit(current, prefix as unknown as JSONPath, placeholder)
-    created.push(prefix)
+    if (existing !== undefined) continue;
+    const nextSegmentIsIndex = Number.isInteger(Number(path[depth + 1]));
+    const placeholder = nextSegmentIsIndex ? [] : {};
+    current = edit(current, prefix as unknown as JSONPath, placeholder);
+    created.push(prefix);
   }
-  return current
+  return current;
 }
 
 function jsonOpHolds(text: string, op: ConfigOp): boolean {
-  if (op.op === "set") return deepEqual(jsonGet(text, op.path), op.value)
-  const list = jsonGet(text, op.path)
-  return Array.isArray(list) && (op.entries ?? []).every((entry) => list.some((item) => deepEqual(item, entry)))
+  if (op.op === "set") return deepEqual(jsonGet(text, op.path), op.value);
+  const list = jsonGet(text, op.path);
+  return Array.isArray(list) && (op.entries ?? []).every((entry) => list.some((item) => deepEqual(item, entry)));
 }
 
 /** The JSON codec: comment-preserving edits on JSONC text. */
@@ -137,15 +141,15 @@ export const jsonCodec: FormatCodec = {
   format: "json",
   load: loadJson,
   apply: (text, edit): AppliedText => {
-    if (edit.format !== "json") throw new Error(`json codec cannot apply a ${edit.format} edit`)
-    const result = applyJsonOps(text, edit.ops)
-    return { text: result.text, recorded: result.recorded, createdParents: result.createdParents }
+    if (edit.format !== "json") throw new Error(`json codec cannot apply a ${edit.format} edit`);
+    const result = applyJsonOps(text, edit.ops);
+    return { text: result.text, recorded: result.recorded, createdParents: result.createdParents };
   },
   verify: (text, edit, op) => {
-    if (edit.format !== "json") throw new Error(`json codec cannot verify a ${edit.format} edit`)
-    const ops = op === undefined ? edit.ops : [op]
-    return ops.every((candidate) => jsonOpHolds(text, candidate))
+    if (edit.format !== "json") throw new Error(`json codec cannot verify a ${edit.format} edit`);
+    const ops = op === undefined ? edit.ops : [op];
+    return ops.every((candidate) => jsonOpHolds(text, candidate));
   },
   revert: (text, recorded) => revertJsonOps(text, recorded.ops, recorded.createdParents ?? []),
   isEffectivelyEmpty: (text) => text.replace(/[{}\s]/g, "").length === 0,
-}
+};

package/src/installer/formats/rules.ts

@@ -1,62 +1,89 @@
-import { existsSync, readFileSync } from "node:fs"
-import type { HostName } from "../types"
-import type { AppliedText, FormatCodec } from "./index"
+import { existsSync, readFileSync } from "node:fs";
+import type { HostName } from "../types";
+import type { AppliedText, FormatCodec } from "./index";
 
 /** Marked-block markers are per host, so multiple hosts can share one rules file. */
 function rulesMarkers(host: HostName): { readonly begin: string; readonly end: string } {
   return {
     begin: `<!-- deepseek-web-retrieval:${host}:rules:begin -->`,
     end: `<!-- deepseek-web-retrieval:${host}:rules:end -->`,
-  }
+  };
 }
 
 /** Wraps rule lines in the host's marked block that apply upserts and uninstall remove. */
 export function buildRulesBlock(host: HostName, lines: readonly string[]): string {
-  const markers = rulesMarkers(host)
-  return [markers.begin, ...lines, markers.end].join("\n")
+  const markers = rulesMarkers(host);
+  return [markers.begin, ...lines, markers.end].join("\n");
 }
 
 /** Replaces the host's existing marked block, or appends one; keeps surrounding text intact. */
 export function upsertBlock(host: HostName, text: string, block: string): string {
-  const without = removeBlock(host, text)
-  const trimmed = without.trimEnd()
-  return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`
+  const without = removeBlock(host, text);
+  const trimmed = without.trimEnd();
+  return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
 }
 
 /** Removes the host's marked block if present; returns the text unchanged otherwise. */
 export function removeBlock(host: HostName, text: string): string {
-  const markers = rulesMarkers(host)
-  const start = text.indexOf(markers.begin)
-  if (start === -1) return text
-  const end = text.indexOf(markers.end)
-  if (end === -1) return text.slice(0, start)
-  let after = text.slice(end + markers.end.length)
-  // Drop the blank lines the upsert added around the block.
-  after = after.replace(/^\n{1,2}/, "")
-  const before = text.slice(0, start)
-  return before.endsWith("\n\n") ? `${before.slice(0, -1)}${after}` : before + after
+  const range = blockRange(host, text);
+  if (range === undefined) return text;
+  // The upsert joins non-empty neighbors with exactly one blank line; removal
+  // mirrors it, so the surrounding spacing stays stable across round-trips
+  // instead of collapsing the separator the block used to occupy.
+  const before = text.slice(0, range.start).trimEnd();
+  const after = text
+    .slice(range.end)
+    .replace(/^\n{1,2}/, "")
+    .trimStart();
+  if (before && after) return `${before}\n\n${after}`;
+  if (before) return `${before}\n`;
+  return after;
 }
 
 export function hasBlock(host: HostName, text: string): boolean {
-  const markers = rulesMarkers(host)
-  return text.includes(markers.begin) && text.includes(markers.end)
+  return blockRange(host, text) !== undefined;
+}
+
+/** Only one complete, ordered marker pair establishes which text we may remove. */
+function blockRange(host: HostName, text: string): { start: number; end: number } | undefined {
+  const markers = rulesMarkers(host);
+  const start = text.indexOf(markers.begin);
+  const end = text.indexOf(markers.end);
+  if (start === -1 && end === -1) return undefined;
+  if (
+    start === -1 ||
+    end < start ||
+    text.indexOf(markers.begin, start + markers.begin.length) !== -1 ||
+    text.indexOf(markers.end, end + markers.end.length) !== -1
+  ) {
+    throw new Error(
+      `malformed rules block for ${host}: expected one begin marker followed by one end marker; repair the markers before retrying`,
+    );
+  }
+  return { start, end: end + markers.end.length };
 }
 
 /** A rules codec is per host: its markers decide which block upsert, verify, and revert touch. */
 export function rulesCodec(host: HostName): FormatCodec {
   return {
     format: "rules",
-    load: (file) =>
-      existsSync(file)
-        ? { exists: true, text: readFileSync(file, "utf8"), value: {}, lossy: false }
-        : { exists: false, text: "", value: {}, lossy: false },
+    load: (file) => {
+      const exists = existsSync(file);
+      const text = exists ? readFileSync(file, "utf8") : "";
+      try {
+        blockRange(host, text);
+        return { exists, text, value: {}, lossy: false };
+      } catch (error) {
+        return { exists, text, value: {}, lossy: false, parseError: String(error) };
+      }
+    },
     apply: (text, edit): AppliedText => {
-      if (edit.format !== "rules") throw new Error(`rules codec cannot apply a ${edit.format} edit`)
-      return { text: upsertBlock(host, text, edit.block), recorded: [], createdParents: [] }
+      if (edit.format !== "rules") throw new Error(`rules codec cannot apply a ${edit.format} edit`);
+      return { text: upsertBlock(host, text, edit.block), recorded: [], createdParents: [] };
     },
     // Rules files are markdown: the block's presence is the only postcondition.
     verify: (text) => hasBlock(host, text),
     revert: (text) => ({ text: removeBlock(host, text), notes: [] }),
     isEffectivelyEmpty: (text) => text.trim().length === 0,
-  }
+  };
 }

package/src/installer/formats/toml.ts

@@ -1,18 +1,18 @@
-import { existsSync, readFileSync } from "node:fs"
-import { parse as parseToml, stringify as stringifyTomlValue } from "smol-toml"
-import type { ConfigOp, RecordedOp } from "../types"
-import type { AppliedText, FormatCodec, LoadedConfig } from "./index"
-import { appendEntries, deepEqual, isPlainObject, removeAt, valueAt } from "./value"
+import { existsSync, readFileSync } from "node:fs";
+import { parse as parseToml, stringify as stringifyTomlValue } from "smol-toml";
+import type { ConfigOp, RecordedOp } from "../types";
+import type { AppliedText, FormatCodec, LoadedConfig } from "./index";
+import { appendEntries, deepEqual, isPlainObject, removeAt, valueAt } from "./value";
 
 /** Reads a TOML config file; a missing file starts empty, an unparsable one carries the error. */
 function loadToml(file: string): LoadedConfig {
-  if (!existsSync(file)) return { exists: false, text: "", value: {}, lossy: false }
-  const text = readFileSync(file, "utf8")
+  if (!existsSync(file)) return { exists: false, text: "", value: {}, lossy: false };
+  const text = readFileSync(file, "utf8");
   try {
-    return { exists: true, text, value: parseToml(text) as Record<string, unknown>, lossy: hasTomlComment(text) }
+    return { exists: true, text, value: parseToml(text) as Record<string, unknown>, lossy: hasTomlComment(text) };
   } catch (error) {
-    const parseError = error instanceof Error ? error.message : String(error)
-    return { exists: true, text, value: {}, lossy: false, parseError }
+    const parseError = error instanceof Error ? error.message : String(error);
+    return { exists: true, text, value: {}, lossy: false, parseError };
   }
 }
 
@@ -21,122 +21,129 @@ function loadToml(file: string): LoadedConfig {
  * strings counts, including trailing comments like `key = "x" # note`.
  */
 export function hasTomlComment(text: string): boolean {
-  let inBasic = false
-  let inLiteral = false
+  let inBasic = false;
+  let inLiteral = false;
   for (let i = 0; i < text.length; i += 1) {
-    const ch = text[i] as string
+    const ch = text[i] as string;
     if (inBasic) {
-      if (ch === "\\") i += 1
-      else if (ch === '"') inBasic = false
-      continue
+      if (ch === "\\") i += 1;
+      else if (ch === '"') inBasic = false;
+      continue;
     }
     if (inLiteral) {
-      if (ch === "'") inLiteral = false
-      continue
+      if (ch === "'") inLiteral = false;
+      continue;
     }
-    if (ch === '"') inBasic = true
-    else if (ch === "'") inLiteral = true
-    else if (ch === "#") return true
+    if (ch === '"') inBasic = true;
+    else if (ch === "'") inLiteral = true;
+    else if (ch === "#") return true;
   }
-  return false
+  return false;
 }
 
 function serializeToml(value: Record<string, unknown>): string {
-  return `${stringifyTomlValue(value)}\n`
+  return `${stringifyTomlValue(value)}\n`;
 }
 
 /**
  * Applies ops to a parsed TOML value, returning the mutated value plus one record
  * per op with the previous value for surgical undo, and the path prefixes created.
  */
-function applyTomlOps(value: Record<string, unknown>, ops: readonly ConfigOp[]): { value: Record<string, unknown>; recorded: RecordedOp[]; createdParents: (readonly string[])[] } {
-  const target: Record<string, unknown> = structuredClone(value)
-  const recorded: RecordedOp[] = []
-  const createdParents: (readonly string[])[] = []
+function applyTomlOps(
+  value: Record<string, unknown>,
+  ops: readonly ConfigOp[],
+): { value: Record<string, unknown>; recorded: RecordedOp[]; createdParents: (readonly string[])[] } {
+  const target: Record<string, unknown> = structuredClone(value);
+  const recorded: RecordedOp[] = [];
+  const createdParents: (readonly string[])[] = [];
   for (const op of ops) {
-    const parent = navigate(target, op.path, createdParents)
-    const key = op.path[op.path.length - 1]
+    const parent = navigate(target, op.path, createdParents);
+    const key = op.path[op.path.length - 1];
     if (op.op === "set") {
-      const previous = Object.prototype.hasOwnProperty.call(parent, key) ? parent[key] : undefined
-      parent[key] = structuredClone(op.value)
-      recorded.push({ op: "set", path: op.path, applied: structuredClone(op.value), previous })
-      continue
+      const previous = Object.hasOwn(parent, key) ? parent[key] : undefined;
+      parent[key] = structuredClone(op.value);
+      recorded.push({ op: "set", path: op.path, applied: structuredClone(op.value), previous });
+      continue;
     }
-    const existing = parent[key]
-    if (existing === undefined) createdParents.push(op.path)
-    const { list, appended } = appendEntries(existing, op.entries ?? [], op.path)
-    parent[key] = [...list, ...appended.map((entry) => structuredClone(entry))]
-    recorded.push({ op: "append-array", path: op.path, applied: appended, previous: undefined })
+    const existing = parent[key];
+    if (existing === undefined) createdParents.push(op.path);
+    const { list, appended } = appendEntries(existing, op.entries ?? [], op.path);
+    parent[key] = [...list, ...appended.map((entry) => structuredClone(entry))];
+    recorded.push({ op: "append-array", path: op.path, applied: appended, previous: undefined });
   }
-  return { value: target, recorded, createdParents }
+  return { value: target, recorded, createdParents };
 }
 
-function navigate(root: Record<string, unknown>, path: readonly string[], created: (readonly string[])[]): Record<string, unknown> {
-  let node = root
+function navigate(
+  root: Record<string, unknown>,
+  path: readonly string[],
+  created: (readonly string[])[],
+): Record<string, unknown> {
+  let node = root;
   for (let depth = 0; depth < path.length - 1; depth += 1) {
-    const key = path[depth] as string
-    const next: unknown = node[key]
+    const key = path[depth] as string;
+    const next: unknown = node[key];
     if (next === undefined) {
-      node[key] = {}
-      created.push(path.slice(0, depth + 1))
+      node[key] = {};
+      created.push(path.slice(0, depth + 1));
     } else if (!isPlainObject(next)) {
       throw new Error(
         `cannot descend into ${path.slice(0, depth + 1).join(".")}: it is ${Array.isArray(next) ? "an array" : `a ${typeof next}`}, not a table`,
-      )
+      );
     }
-    node = node[key] as Record<string, unknown>
+    node = node[key] as Record<string, unknown>;
   }
-  return node
+  return node;
 }
 
 /** Surgical undo on a parsed TOML object; user edits made after install win. */
 function revertTomlOps(value: Record<string, unknown>, ops: readonly RecordedOp[]): string[] {
-  const notes: string[] = []
+  const notes: string[] = [];
   for (const record of [...ops].reverse()) {
     if (record.op === "set") {
-      const now = valueAt(value, record.path)
-      if (now === undefined) continue
+      const now = valueAt(value, record.path);
+      if (now === undefined) continue;
       if (!deepEqual(now, record.applied)) {
-        notes.push(`${record.path.join(".")}: current value differs from what the installer wrote; left untouched`)
-        continue
+        notes.push(`${record.path.join(".")}: current value differs from what the installer wrote; left untouched`);
+        continue;
       }
       if (record.previous === undefined) {
-        removeAt(value, record.path)
+        removeAt(value, record.path);
       } else {
-        setValueAt(value, record.path, record.previous)
+        setValueAt(value, record.path, record.previous);
       }
     } else {
-      const entries = Array.isArray(record.applied) ? record.applied : []
+      const entries = Array.isArray(record.applied) ? record.applied : [];
       for (const entry of entries) {
-        const list = valueAt(value, record.path)
-        if (!Array.isArray(list)) continue
-        const index = list.findIndex((item) => deepEqual(item, entry))
-        if (index === -1) continue
-        list.splice(index, 1)
+        const list = valueAt(value, record.path);
+        if (!Array.isArray(list)) continue;
+        const index = list.findIndex((item) => deepEqual(item, entry));
+        if (index === -1) continue;
+        list.splice(index, 1);
       }
     }
   }
-  return notes
+  return notes;
 }
 
 /** Removes path prefixes the installer created when they are left empty, newest first. */
 function pruneCreatedParents(value: Record<string, unknown>, parents: readonly (readonly string[])[]): void {
   for (const parent of [...parents].reverse()) {
-    const current = valueAt(value, parent)
-    if (isPlainObject(current) && Object.keys(current).length === 0) removeAt(value, parent)
+    const current = valueAt(value, parent);
+    if (isPlainObject(current) && Object.keys(current).length === 0) removeAt(value, parent);
   }
 }
 
 function setValueAt(value: Record<string, unknown>, path: readonly string[], replacement: unknown): void {
-  const parent = valueAt(value, path.slice(0, -1))
-  if (isPlainObject(parent)) parent[path[path.length - 1] as string] = replacement
+  const parent = valueAt(value, path.slice(0, -1));
+  if (isPlainObject(parent)) parent[path[path.length - 1] as string] = replacement;
 }
 
 function tomlOpHolds(text: string, op: ConfigOp): boolean {
-  const value = parseToml(text) as Record<string, unknown>
-  const current = valueAt(value, op.path)
-  if (op.op === "set") return deepEqual(current, op.value)
-  return Array.isArray(current) && (op.entries ?? []).every((entry) => current.some((item) => deepEqual(item, entry)))
+  const value = parseToml(text) as Record<string, unknown>;
+  const current = valueAt(value, op.path);
+  if (op.op === "set") return deepEqual(current, op.value);
+  return Array.isArray(current) && (op.entries ?? []).every((entry) => current.some((item) => deepEqual(item, entry)));
 }
 
 /** The TOML codec: ops on a parsed value, serialized lossily (comments drop on rewrite). */
@@ -144,20 +151,20 @@ export const tomlCodec: FormatCodec = {
   format: "toml",
   load: loadToml,
   apply: (text, edit): AppliedText => {
-    if (edit.format !== "toml") throw new Error(`toml codec cannot apply a ${edit.format} edit`)
-    const result = applyTomlOps(parseToml(text) as Record<string, unknown>, edit.ops)
-    return { text: serializeToml(result.value), recorded: result.recorded, createdParents: result.createdParents }
+    if (edit.format !== "toml") throw new Error(`toml codec cannot apply a ${edit.format} edit`);
+    const result = applyTomlOps(parseToml(text) as Record<string, unknown>, edit.ops);
+    return { text: serializeToml(result.value), recorded: result.recorded, createdParents: result.createdParents };
   },
   verify: (text, edit, op) => {
-    if (edit.format !== "toml") throw new Error(`toml codec cannot verify a ${edit.format} edit`)
-    const ops = op === undefined ? edit.ops : [op]
-    return ops.every((candidate) => tomlOpHolds(text, candidate))
+    if (edit.format !== "toml") throw new Error(`toml codec cannot verify a ${edit.format} edit`);
+    const ops = op === undefined ? edit.ops : [op];
+    return ops.every((candidate) => tomlOpHolds(text, candidate));
   },
   revert: (text, recorded) => {
-    const value = parseToml(text) as Record<string, unknown>
-    const notes = revertTomlOps(value, recorded.ops)
-    pruneCreatedParents(value, recorded.createdParents ?? [])
-    return { text: serializeToml(value), notes }
+    const value = parseToml(text) as Record<string, unknown>;
+    const notes = revertTomlOps(value, recorded.ops);
+    pruneCreatedParents(value, recorded.createdParents ?? []);
+    return { text: serializeToml(value), notes };
   },
   isEffectivelyEmpty: (text) => Object.keys(parseToml(text) as Record<string, unknown>).length === 0,
-}
+};