@svilupp/hash-edit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jan Siml
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# hash-edit
+
+Minimal AI-agent file read/edit/write tools with line-hash anchors for TypeScript.
+
+## Install
+
+Bun:
+
+```bash
+bun add @svilupp/hash-edit
+```
+
+Node.js:
+
+```bash
+npm install @svilupp/hash-edit
+```
+
+## Quick start
+
+```typescript
+import { HashEditHarness } from "@svilupp/hash-edit";
+
+const h = new HashEditHarness("/path/to/project");
+
+// 1. Read — returns rendered lines with hashes and a file version
+const result = await h.read("src/app.ts");
+// result.version === "4a3f..."
+// result.lines === ["1:ab|import fs from 'fs'", "2:cd|", "3:ef|export function main() {}"]
+
+// 2. Edit — anchored ops, verified against expected_version
+await h.edit(
+  "src/app.ts",
+  [
+    { op: "replace", line: 3, hash: "ef", lines: ["export function main() {", "  return 0;", "}"] },
+  ],
+  { expected_version: result.version },
+);
+
+// 3. Write — safely overwrite an existing file (version required) or create a new one
+const current = await h.read("src/app.ts");
+await h.write("src/app.ts", "// new content\n", { expected_version: current.version });
+```
+
+## Windowed reads
+
+For large files, read only the lines you need. This can save 55–95% of tokens sent to the model:
+
+```typescript
+// 1 000-line file — read only lines 400–450
+const window = await h.read("src/big.ts", { start_line: 400, end_line: 450 });
+// window.lines.length === 51
+// window.total_lines === 1000  ← tells the model the full file size
+// window.version              ← same digest as a full-file read; valid for edit()
+```
+
+The returned `version` is a full-file blake2s digest, so it can be passed directly to `edit()` without re-reading the whole file.
+
+## Error classes
+
+| Error | When |
+|-------|------|
+| `VersionConflictError` | File changed since last read |
+| `AnchorMismatchError` | Hash doesn't match current line; includes updated rendered context |
+| `InvalidOperationError` | Bad op payload (e.g. missing `hash`, no-op replace, out-of-range line) |
+| `PathEscapeError` | Path escapes the configured root directory |
+| `MixedNewlineError` | File uses more than one newline style |
+| `FileEncodingError` | File cannot be decoded with the configured encoding (UTF-8 by default) |
+
+## Conditional exports
+
+Bun users get direct TypeScript source via the `bun` conditional export — no build step needed. Node.js consumers get pre-built ESM (`dist/index.js`) and CJS (`dist/index.cjs`) bundles.
+
+## See also
+
+[Root README](https://github.com/jansiml/hash-edit#readme) — design rationale, Python package, shared fixture corpus, and benchmark results.

package/dist/index.cjs

@@ -0,0 +1,443 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AnchorMismatchError: () => AnchorMismatchError,
+  FileEncodingError: () => FileEncodingError,
+  HashEditError: () => HashEditError,
+  HashEditHarness: () => HashEditHarness,
+  InvalidOperationError: () => InvalidOperationError,
+  MixedNewlineError: () => MixedNewlineError,
+  PathEscapeError: () => PathEscapeError,
+  VersionConflictError: () => VersionConflictError,
+  computeLineHash: () => computeLineHash,
+  renderLine: () => renderLine,
+  renderLines: () => renderLines,
+  stripRenderPrefixes: () => stripRenderPrefixes
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var DEFAULT_ENCODING = "utf-8";
+var DEFAULT_HASH_LENGTH = 2;
+var UTF8_BOM = Buffer.from([239, 187, 191]);
+var PREFIX_RE = /^\s*\d+:[0-9a-f]{2,}\|/;
+var HashEditError = class extends Error {
+};
+var PathEscapeError = class extends HashEditError {
+};
+var MixedNewlineError = class extends HashEditError {
+};
+var FileEncodingError = class extends HashEditError {
+};
+var InvalidOperationError = class extends HashEditError {
+};
+var VersionConflictError = class extends HashEditError {
+  path;
+  expected;
+  actual;
+  constructor(path, expected, actual) {
+    const message = expected === null ? `${path} already exists. read() first and pass expected_version to overwrite safely.` : `Version conflict for ${path}: expected ${expected}, actual ${actual}. Re-read the file first.`;
+    super(message);
+    this.path = path;
+    this.expected = expected;
+    this.actual = actual;
+  }
+};
+var AnchorMismatchError = class extends HashEditError {
+  mismatches;
+  constructor(message, mismatches) {
+    super(message);
+    this.mismatches = mismatches;
+  }
+};
+function newlineSeparator(style) {
+  if (style === "lf") return "\n";
+  if (style === "crlf") return "\r\n";
+  if (style === "cr") return "\r";
+  return "\n";
+}
+function detectNewlineStyle(text) {
+  const matches = text.match(/\r\n|\n|\r/g) ?? [];
+  const unique = new Set(matches);
+  if (unique.size > 1) {
+    throw new MixedNewlineError(`Mixed newline styles detected: ${Array.from(unique).join(", ")}`);
+  }
+  if (matches.length === 0) {
+    return { newline: "none", has_final_newline: false, lines: text === "" ? [] : [text] };
+  }
+  const separator = matches[0] ?? "\n";
+  const newline = separator === "\n" ? "lf" : separator === "\r\n" ? "crlf" : "cr";
+  const has_final_newline = text.endsWith(separator);
+  const split = text.split(separator);
+  const lines = has_final_newline ? split.slice(0, -1) : split;
+  return { newline, has_final_newline, lines };
+}
+function joinText(lines, newline, hasFinalNewline) {
+  if (lines.length === 0) return "";
+  const separator = newlineSeparator(newline);
+  let text = lines.join(separator);
+  if (hasFinalNewline) text += separator;
+  return text;
+}
+function versionForBytes(data) {
+  return (0, import_node_crypto.createHash)("blake2s256").update(data).digest("hex").slice(0, 32);
+}
+async function pathExists(path) {
+  try {
+    await (0, import_promises.stat)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function computeLineHash(lineNumber, text, hashLength = DEFAULT_HASH_LENGTH) {
+  if (hashLength < 2) throw new Error("hashLength must be >= 2");
+  const normalized = text.replace(/\r/g, "").replace(/[ \t]+$/u, "");
+  const material = /[\p{L}\p{N}]/u.test(normalized) ? normalized : `${lineNumber}\0${normalized}`;
+  return (0, import_node_crypto.createHash)("blake2s256").update(material, DEFAULT_ENCODING).digest("hex").slice(0, hashLength);
+}
+function renderLine(lineNumber, text, hashLength = DEFAULT_HASH_LENGTH) {
+  return `${lineNumber}:${computeLineHash(lineNumber, text, hashLength)}|${text}`;
+}
+function renderLines(lines, startLine = 1, hashLength = DEFAULT_HASH_LENGTH) {
+  return lines.map((line, index) => renderLine(startLine + index, line, hashLength));
+}
+function stripRenderPrefixes(lines) {
+  const nonEmpty = lines.filter((line) => line !== "");
+  if (nonEmpty.length > 0 && nonEmpty.every((line) => PREFIX_RE.test(line))) {
+    return lines.map((line) => line.replace(PREFIX_RE, ""));
+  }
+  return [...lines];
+}
+function mismatchMessage(path, lines, hashLength, mismatches) {
+  const displayLines = /* @__PURE__ */ new Set();
+  for (const mismatch of mismatches) {
+    for (let line = Math.max(1, mismatch.line - 2); line <= Math.min(lines.length, mismatch.line + 2); line += 1) {
+      displayLines.add(line);
+    }
+  }
+  const rendered = [
+    `Anchors are stale in ${path}. Re-read the file and use the updated rendered lines below.`
+  ];
+  if (displayLines.size === 0) return rendered.join("\n");
+  rendered.push("");
+  const mismatchSet = new Set(mismatches.map((mismatch) => mismatch.line));
+  let previous = -1;
+  for (const lineNumber of [...displayLines].sort((left, right) => left - right)) {
+    if (previous !== -1 && lineNumber > previous + 1) {
+      rendered.push("    ...");
+    }
+    const prefix = mismatchSet.has(lineNumber) ? ">>> " : "    ";
+    rendered.push(prefix + renderLine(lineNumber, lines[lineNumber - 1] ?? "", hashLength));
+    previous = lineNumber;
+  }
+  return rendered.join("\n");
+}
+var HashEditHarness = class {
+  #root;
+  #resolvedRoot;
+  #encoding;
+  #hashLength;
+  constructor(root = ".", options = {}) {
+    this.#root = (0, import_node_path.resolve)(root);
+    this.#resolvedRoot = resolveExistingPath(this.#root);
+    this.#encoding = options.default_encoding ?? DEFAULT_ENCODING;
+    this.#hashLength = options.hash_length ?? DEFAULT_HASH_LENGTH;
+  }
+  resolvePath(path) {
+    const absolute = (0, import_node_path.resolve)(this.#root, path);
+    const resolved = resolveExistingPath(absolute);
+    const rel = (0, import_node_path.relative)(this.#resolvedRoot, resolved);
+    if (rel.startsWith("..") || (0, import_node_path.isAbsolute)(rel)) {
+      throw new PathEscapeError(`${path} escapes root ${this.#root}`);
+    }
+    return resolved;
+  }
+  async read(path, options = {}) {
+    const resolved = this.resolvePath(path);
+    const snapshot = await this.readSnapshot(resolved);
+    if (snapshot.lines.length === 0) {
+      return {
+        path: snapshot.path,
+        version: snapshot.version,
+        encoding: snapshot.encoding,
+        bom: snapshot.bom,
+        newline: snapshot.newline,
+        has_final_newline: snapshot.has_final_newline,
+        hash_length: this.#hashLength,
+        total_lines: 0,
+        start_line: 0,
+        end_line: 0,
+        lines: []
+      };
+    }
+    const startLine = options.start_line ?? 1;
+    const endLine = options.end_line ?? snapshot.lines.length;
+    if (startLine < 1 || endLine < startLine || endLine > snapshot.lines.length) {
+      throw new InvalidOperationError(
+        `Invalid read window for ${snapshot.path}: start_line=${startLine}, end_line=${endLine}, total_lines=${snapshot.lines.length}`
+      );
+    }
+    return {
+      path: snapshot.path,
+      version: snapshot.version,
+      encoding: snapshot.encoding,
+      bom: snapshot.bom,
+      newline: snapshot.newline,
+      has_final_newline: snapshot.has_final_newline,
+      hash_length: this.#hashLength,
+      total_lines: snapshot.lines.length,
+      start_line: startLine,
+      end_line: endLine,
+      lines: renderLines(snapshot.lines.slice(startLine - 1, endLine), startLine, this.#hashLength)
+    };
+  }
+  async edit(path, ops, options) {
+    const resolved = this.resolvePath(path);
+    const snapshot = await this.readSnapshot(resolved);
+    if (options.expected_version !== snapshot.version) {
+      throw new VersionConflictError(snapshot.path, options.expected_version, snapshot.version);
+    }
+    const operations = Array.isArray(ops) ? [...ops] : [ops];
+    if (operations.length === 0) {
+      throw new InvalidOperationError("edit() requires at least one operation");
+    }
+    const lines = [...snapshot.lines];
+    const mismatches = [];
+    const validateAnchor = (line, expectedHash) => {
+      if (line < 1 || line > lines.length) {
+        throw new InvalidOperationError(
+          `Line ${line} is out of range for ${snapshot.path} (total_lines=${lines.length})`
+        );
+      }
+      const actual = computeLineHash(line, lines[line - 1] ?? "", this.#hashLength);
+      if (actual !== expectedHash) {
+        mismatches.push({ line, expected: expectedHash, actual });
+      }
+    };
+    for (const operation of operations) {
+      validateAnchor(operation.line, operation.hash);
+      if ("end_line" in operation && operation.end_line !== void 0) {
+        if (!operation.end_hash) {
+          throw new InvalidOperationError("Range edits require end_hash");
+        }
+        validateAnchor(operation.end_line, operation.end_hash);
+        if (operation.end_line < operation.line) {
+          throw new InvalidOperationError("end_line must be >= line");
+        }
+      }
+    }
+    if (mismatches.length > 0) {
+      throw new AnchorMismatchError(
+        mismatchMessage(snapshot.path, lines, this.#hashLength, mismatches),
+        mismatches
+      );
+    }
+    const sortKey = (operation) => {
+      const lineNumber = "end_line" in operation && operation.end_line !== void 0 ? operation.end_line : operation.line;
+      const precedence = { replace: 0, delete: 0, insert_after: 1, insert_before: 2 }[operation.op];
+      return [-lineNumber, precedence];
+    };
+    let firstChangedLine = null;
+    for (const operation of [...operations].sort((left, right) => {
+      const [leftLine, leftPrec] = sortKey(left);
+      const [rightLine, rightPrec] = sortKey(right);
+      return leftLine - rightLine || leftPrec - rightPrec;
+    })) {
+      if (operation.op === "replace") {
+        const replacement = stripRenderPrefixes([...operation.lines]);
+        const endLine = operation.end_line ?? operation.line;
+        const current = lines.slice(operation.line - 1, endLine);
+        if (current.length === replacement.length && current.every((line, index) => line === replacement[index])) {
+          throw new InvalidOperationError(
+            `No changes made to ${snapshot.path}. Replacement for ${operation.line}:${operation.hash} is identical.`
+          );
+        }
+        lines.splice(operation.line - 1, endLine - operation.line + 1, ...replacement);
+        firstChangedLine = firstChangedLine === null ? operation.line : Math.min(firstChangedLine, operation.line);
+      } else if (operation.op === "delete") {
+        const endLine = operation.end_line ?? operation.line;
+        lines.splice(operation.line - 1, endLine - operation.line + 1);
+        firstChangedLine = firstChangedLine === null ? operation.line : Math.min(firstChangedLine, operation.line);
+      } else if (operation.op === "insert_before") {
+        const inserted = stripRenderPrefixes([...operation.lines]);
+        const payload = inserted.length === 0 ? [""] : inserted;
+        lines.splice(operation.line - 1, 0, ...payload);
+        firstChangedLine = firstChangedLine === null ? operation.line : Math.min(firstChangedLine, operation.line);
+      } else {
+        const inserted = stripRenderPrefixes([...operation.lines]);
+        const payload = inserted.length === 0 ? [""] : inserted;
+        lines.splice(operation.line, 0, ...payload);
+        const insertionLine = operation.line + 1;
+        firstChangedLine = firstChangedLine === null ? insertionLine : Math.min(firstChangedLine, insertionLine);
+      }
+    }
+    const versionAfter = await this.writeSnapshot(resolved, {
+      lines,
+      bom: snapshot.bom,
+      newline: snapshot.newline,
+      has_final_newline: snapshot.has_final_newline
+    });
+    return {
+      path: snapshot.path,
+      version_before: snapshot.version,
+      version_after: versionAfter,
+      applied: operations.length,
+      first_changed_line: firstChangedLine,
+      encoding: snapshot.encoding,
+      bom: snapshot.bom,
+      newline: snapshot.newline,
+      has_final_newline: snapshot.has_final_newline,
+      total_lines: lines.length
+    };
+  }
+  async write(path, text, options = {}) {
+    const resolved = this.resolvePath(path);
+    const created = !await pathExists(resolved);
+    const input = detectNewlineStyle(text);
+    let bom = false;
+    let newline = input.newline;
+    let versionAfter;
+    if (created) {
+      versionAfter = await this.writeSnapshot(resolved, {
+        lines: input.lines,
+        bom: false,
+        newline: input.newline,
+        has_final_newline: input.has_final_newline
+      });
+    } else {
+      const snapshot = await this.readSnapshot(resolved);
+      if ((options.expected_version ?? null) !== snapshot.version) {
+        throw new VersionConflictError(
+          snapshot.path,
+          options.expected_version ?? null,
+          snapshot.version
+        );
+      }
+      bom = snapshot.bom;
+      newline = snapshot.newline === "none" ? input.newline : snapshot.newline;
+      versionAfter = await this.writeSnapshot(resolved, {
+        lines: input.lines,
+        bom,
+        newline,
+        has_final_newline: input.has_final_newline
+      });
+    }
+    return {
+      path: (0, import_node_path.relative)(this.#root, resolved),
+      version_after: versionAfter,
+      created,
+      encoding: this.#encoding,
+      bom,
+      newline,
+      has_final_newline: input.has_final_newline,
+      total_lines: input.lines.length
+    };
+  }
+  async readSnapshot(path) {
+    const raw = Buffer.from(await (0, import_promises.readFile)(path));
+    const version = versionForBytes(raw);
+    const bom = raw.subarray(0, UTF8_BOM.length).equals(UTF8_BOM);
+    const payload = bom ? raw.subarray(UTF8_BOM.length) : raw;
+    let text;
+    try {
+      text = new TextDecoder(this.#encoding, { fatal: true }).decode(payload);
+    } catch (error) {
+      throw new FileEncodingError(`${(0, import_node_path.relative)(this.#root, path)} is not valid ${this.#encoding}`, {
+        cause: error
+      });
+    }
+    const parsed = detectNewlineStyle(text);
+    return {
+      path: (0, import_node_path.relative)(this.#root, path),
+      version,
+      encoding: this.#encoding,
+      bom,
+      newline: parsed.newline,
+      has_final_newline: parsed.has_final_newline,
+      lines: parsed.lines
+    };
+  }
+  async writeSnapshot(path, options) {
+    await (0, import_promises.mkdir)((0, import_node_path.dirname)(path), { recursive: true });
+    const text = joinText(options.lines, options.newline, options.has_final_newline);
+    let payload = Buffer.from(text, this.#encoding);
+    if (options.bom) {
+      payload = Buffer.concat([UTF8_BOM, payload]);
+    }
+    const tempPath = `${path}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+    let mode;
+    try {
+      mode = (await (0, import_promises.stat)(path)).mode;
+    } catch {
+    }
+    try {
+      await (0, import_promises.writeFile)(tempPath, payload);
+      if (mode !== void 0) {
+        await (0, import_promises.chmod)(tempPath, mode);
+      }
+      await (0, import_promises.rename)(tempPath, path);
+    } finally {
+      await (0, import_promises.rm)(tempPath, { force: true });
+    }
+    return versionForBytes(payload);
+  }
+};
+function resolveExistingPath(path) {
+  const missingSegments = [];
+  let current = path;
+  while (true) {
+    try {
+      const resolved = import_node_fs.realpathSync.native(current);
+      const suffix = [...missingSegments].reverse();
+      return missingSegments.length === 0 ? resolved : (0, import_node_path.join)(resolved, ...suffix);
+    } catch (error) {
+      const candidate = error;
+      if (candidate.code !== "ENOENT") {
+        throw candidate;
+      }
+      const parent = (0, import_node_path.dirname)(current);
+      if (parent === current) {
+        return (0, import_node_path.join)(current, ...[...missingSegments].reverse());
+      }
+      missingSegments.push((0, import_node_path.basename)(current));
+      current = parent;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnchorMismatchError,
+  FileEncodingError,
+  HashEditError,
+  HashEditHarness,
+  InvalidOperationError,
+  MixedNewlineError,
+  PathEscapeError,
+  VersionConflictError,
+  computeLineHash,
+  renderLine,
+  renderLines,
+  stripRenderPrefixes
+});

package/dist/index.d.cts

@@ -0,0 +1,118 @@
+type NewlineStyle = "lf" | "crlf" | "cr" | "none";
+type ReplaceOp = {
+    op: "replace";
+    line: number;
+    hash: string;
+    lines: string[];
+    end_line?: number;
+    end_hash?: string;
+};
+type InsertBeforeOp = {
+    op: "insert_before";
+    line: number;
+    hash: string;
+    lines: string[];
+};
+type InsertAfterOp = {
+    op: "insert_after";
+    line: number;
+    hash: string;
+    lines: string[];
+};
+type DeleteOp = {
+    op: "delete";
+    line: number;
+    hash: string;
+    end_line?: number;
+    end_hash?: string;
+};
+type EditOp = ReplaceOp | InsertBeforeOp | InsertAfterOp | DeleteOp;
+type ReadResult = {
+    path: string;
+    version: string;
+    encoding: string;
+    bom: boolean;
+    newline: NewlineStyle;
+    has_final_newline: boolean;
+    hash_length: number;
+    total_lines: number;
+    start_line: number;
+    end_line: number;
+    lines: string[];
+};
+type EditResult = {
+    path: string;
+    version_before: string;
+    version_after: string;
+    applied: number;
+    first_changed_line: number | null;
+    encoding: string;
+    bom: boolean;
+    newline: NewlineStyle;
+    has_final_newline: boolean;
+    total_lines: number;
+};
+type WriteResult = {
+    path: string;
+    version_after: string;
+    created: boolean;
+    encoding: string;
+    bom: boolean;
+    newline: NewlineStyle;
+    has_final_newline: boolean;
+    total_lines: number;
+};
+declare class HashEditError extends Error {
+}
+declare class PathEscapeError extends HashEditError {
+}
+declare class MixedNewlineError extends HashEditError {
+}
+declare class FileEncodingError extends HashEditError {
+}
+declare class InvalidOperationError extends HashEditError {
+}
+declare class VersionConflictError extends HashEditError {
+    path: string;
+    expected: string | null;
+    actual: string;
+    constructor(path: string, expected: string | null, actual: string);
+}
+declare class AnchorMismatchError extends HashEditError {
+    mismatches: Array<{
+        line: number;
+        expected: string;
+        actual: string;
+    }>;
+    constructor(message: string, mismatches: Array<{
+        line: number;
+        expected: string;
+        actual: string;
+    }>);
+}
+declare function computeLineHash(lineNumber: number, text: string, hashLength?: number): string;
+declare function renderLine(lineNumber: number, text: string, hashLength?: number): string;
+declare function renderLines(lines: string[], startLine?: number, hashLength?: number): string[];
+declare function stripRenderPrefixes(lines: string[]): string[];
+declare class HashEditHarness {
+    #private;
+    constructor(root?: string, options?: {
+        default_encoding?: string;
+        hash_length?: number;
+    });
+    resolvePath(path: string): string;
+    read(path: string, options?: {
+        start_line?: number;
+        end_line?: number;
+    }): Promise<ReadResult>;
+    edit(path: string, ops: EditOp | EditOp[], options: {
+        expected_version: string;
+    }): Promise<EditResult>;
+    write(path: string, text: string, options?: {
+        expected_version?: string;
+    }): Promise<WriteResult>;
+    private readSnapshot;
+    private writeSnapshot;
+}
+
+export { AnchorMismatchError, type DeleteOp, type EditOp, type EditResult, FileEncodingError, HashEditError, HashEditHarness, type InsertAfterOp, type InsertBeforeOp, InvalidOperationError, MixedNewlineError, type NewlineStyle, PathEscapeError, type ReadResult, type ReplaceOp, VersionConflictError, type WriteResult, computeLineHash, renderLine, renderLines, stripRenderPrefixes };