@chances-ai/engine 27.0.0 → 29.0.0

package/dist/hashline/fs.js

@@ -0,0 +1,123 @@
+/**
+ * Storage seam for the hashline patcher. {@link Filesystem} is intentionally
+ * minimal — `readText`, `writeText`, `exists` — so any backing store can be
+ * adapted: disk, memory, S3, an LSP text-document protocol, a Git tree, a
+ * VFS, etc. Ported from oh-my-pi `packages/hashline/src/fs.ts`.
+ *
+ * **chances-cli change (7.9):** the Bun-based `NodeFilesystem` is dropped (it
+ * used `Bun.file`/`Bun.write`, unavailable under Node — serve-on-Node). The
+ * disk-backed implementation lives in the engine `edit` tool as `EngineToolFs`,
+ * which routes every write through `guardWrite` (realpath jail + protected-path
+ * floor) + `writeFileAtomic` + fs-scan cache invalidation. {@link
+ * InMemoryFilesystem} stays here for tests/sandboxes.
+ *
+ * The patcher does its own BOM stripping and LF normalization between
+ * {@link Filesystem.readText} and {@link Filesystem.writeText}; the FS deals
+ * only in raw text strings.
+ */
+/**
+ * ENOENT-like error thrown by {@link Filesystem.readText} when a path is
+ * missing. Carrying a `code` property keeps the contract compatible with
+ * `node:fs` callers that already check `err.code === "ENOENT"`.
+ */
+export class NotFoundError extends Error {
+    code = "ENOENT";
+    constructor(path, cause) {
+        super(`File not found: ${path}`);
+        this.name = "NotFoundError";
+        if (cause !== undefined)
+            this.cause = cause;
+    }
+}
+/** Type guard for {@link NotFoundError} and structurally-compatible errors. */
+export function isNotFound(error) {
+    if (error instanceof NotFoundError)
+        return true;
+    if (error instanceof Error && error.code === "ENOENT")
+        return true;
+    return false;
+}
+/**
+ * Abstract storage backend the {@link Patcher} reads from and writes to.
+ * Subclass for new backends; the package ships {@link InMemoryFilesystem} for
+ * tests and the engine wires `EngineToolFs` for disk.
+ *
+ * Implementations work with raw text — the patcher handles BOM stripping and
+ * line-ending normalization itself. `readText` MUST throw {@link
+ * NotFoundError} (or any error for which {@link isNotFound} returns true)
+ * when the path doesn't exist; that's how the patcher detects a create-vs-
+ * update.
+ */
+export class Filesystem {
+    /** Validate that `path` is writable before a prepared batch starts committing. */
+    async preflightWrite(_path) { }
+    /** Return true when the path exists and can be read. Default: probe via {@link readText}. */
+    async exists(path) {
+        try {
+            await this.readText(path);
+            return true;
+        }
+        catch (error) {
+            if (isNotFound(error))
+                return false;
+            throw error;
+        }
+    }
+    /**
+     * Canonical path used as a key by external caches (e.g. snapshot
+     * stores). The default is identity; override to return an absolute or
+     * otherwise canonicalised path so producers and consumers of cached
+     * snapshots agree on the key without each having to redo the resolution.
+     */
+    canonicalPath(path) {
+        return path;
+    }
+}
+/**
+ * In-memory {@link Filesystem}. Useful for tests, sandboxes, dry-runs, and as
+ * a building block for stacked adapters (e.g. an LRU layer on top).
+ */
+export class InMemoryFilesystem extends Filesystem {
+    #files = new Map();
+    constructor(initial) {
+        super();
+        if (initial) {
+            for (const [path, content] of initial)
+                this.#files.set(path, content);
+        }
+    }
+    async readText(path) {
+        const text = this.#files.get(path);
+        if (text === undefined)
+            throw new NotFoundError(path);
+        return text;
+    }
+    async writeText(path, content) {
+        this.#files.set(path, content);
+        return { text: content };
+    }
+    async exists(path) {
+        return this.#files.has(path);
+    }
+    /** Synchronous helper for setting up fixtures without awaiting. */
+    set(path, content) {
+        this.#files.set(path, content);
+    }
+    /** Synchronous helper for inspecting state without awaiting. */
+    get(path) {
+        return this.#files.get(path);
+    }
+    /** Remove a single entry. Returns true when something was removed. */
+    delete(path) {
+        return this.#files.delete(path);
+    }
+    /** Wipe all entries. */
+    clear() {
+        this.#files.clear();
+    }
+    /** Iterate `[path, content]` pairs. */
+    entries() {
+        return this.#files.entries();
+    }
+}
+//# sourceMappingURL=fs.js.map

package/dist/hashline/fs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.js","sourceRoot":"","sources":["../../src/hashline/fs.ts"],"names":[],"mappings":"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"}

package/dist/hashline/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @chances-ai/engine hashline core — a compact, line-anchored patch language
+ * and applier for LLM-driven file edits. Ported from oh-my-pi
+ * `packages/hashline` (7.9 task 09); see the per-file headers for the
+ * chances-cli deltas (cross-runtime hash, exact-text integrity, FS seam).
+ *
+ * Every section binds to a whole-file content hash so stale anchors are
+ * rejected before they corrupt code; the patcher abstracts over the
+ * filesystem so the same core works on disk, in memory, or against any custom
+ * backend. The engine `edit` tool wires `EngineToolFs` (guardWrite + atomic) +
+ * a `native.blockRangeAt` block resolver + a per-session `SnapshotStore`.
+ */
+export * from "./apply.js";
+export * from "./block.js";
+export * from "./format.js";
+export * from "./fs.js";
+export * from "./input.js";
+export * from "./messages.js";
+export * from "./mismatch.js";
+export * from "./normalize.js";
+export * from "./parser.js";
+export * from "./patcher.js";
+export * from "./recovery.js";
+export * from "./snapshots.js";
+export * from "./tokenizer.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hashline/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hashline/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC"}

package/dist/hashline/index.js

@@ -0,0 +1,27 @@
+/**
+ * @chances-ai/engine hashline core — a compact, line-anchored patch language
+ * and applier for LLM-driven file edits. Ported from oh-my-pi
+ * `packages/hashline` (7.9 task 09); see the per-file headers for the
+ * chances-cli deltas (cross-runtime hash, exact-text integrity, FS seam).
+ *
+ * Every section binds to a whole-file content hash so stale anchors are
+ * rejected before they corrupt code; the patcher abstracts over the
+ * filesystem so the same core works on disk, in memory, or against any custom
+ * backend. The engine `edit` tool wires `EngineToolFs` (guardWrite + atomic) +
+ * a `native.blockRangeAt` block resolver + a per-session `SnapshotStore`.
+ */
+export * from "./apply.js";
+export * from "./block.js";
+export * from "./format.js";
+export * from "./fs.js";
+export * from "./input.js";
+export * from "./messages.js";
+export * from "./mismatch.js";
+export * from "./normalize.js";
+export * from "./parser.js";
+export * from "./patcher.js";
+export * from "./recovery.js";
+export * from "./snapshots.js";
+export * from "./tokenizer.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/hashline/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hashline/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC"}

package/dist/hashline/input.d.ts

@@ -0,0 +1,101 @@
+import type { ApplyResult, BlockResolver, Edit, SplitOptions } from "./types.js";
+interface RawSection {
+    path: string;
+    fileHash?: string;
+    diff: string;
+}
+/**
+ * Returns true when the input contains at least one line that the tokenizer
+ * recognizes as a hashline op. Used by streaming previews to decide whether
+ * the partial input is worth treating as a hashline patch yet.
+ */
+export declare function containsRecognizableHashlineOperations(input: string): boolean;
+/**
+ * Snapshot of one section in a parsed {@link Patch}: a target file plus the
+ * lazily-parsed list of edits that should land on it. Constructed by
+ * {@link Patch.parse}; consumers usually iterate `patch.sections` rather
+ * than build these directly.
+ */
+export declare class PatchSection {
+    #private;
+    readonly path: string;
+    readonly fileHash: string | undefined;
+    readonly diff: string;
+    constructor(raw: RawSection);
+    /**
+     * Parse this section's diff body. Cached: subsequent calls return the
+     * same `{ edits, warnings }` object so callers can safely call this from
+     * multiple paths (preflight, apply, diff-preview).
+     */
+    parse(): {
+        edits: Edit[];
+        warnings: readonly string[];
+    };
+    /** Parsed edits for this section. */
+    get edits(): readonly Edit[];
+    /** Warnings emitted during parsing of this section. */
+    get warnings(): readonly string[];
+    /**
+     * True when at least one edit anchors to concrete file content. Pure
+     * `insert head:` / `insert tail:` literal inserts do not count: those are
+     * safe to apply to files that don't yet exist.
+     */
+    get hasAnchorScopedEdit(): boolean;
+    /** Anchor lines touched by this section, sorted ascending and deduplicated. */
+    collectAnchorLines(): readonly number[];
+    /**
+     * Apply this section's edits to `text` and return the post-edit result.
+     * Pure: does no I/O, does not validate the section snapshot tag. The
+     * {@link Patcher} owns tag validation and recovery; reach for this
+     * method directly when you've already validated the file content and
+     * just want the result.
+     *
+     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * unresolvable block throws (this is the final, authoritative preview path).
+     */
+    applyTo(text: string, blockResolver?: BlockResolver): ApplyResult;
+    /**
+     * Streaming-tolerant counterpart to {@link applyTo}. Uses
+     * {@link parsePatchStreaming} so a trailing in-flight op (no payload yet,
+     * or a per-token parse error mid-stream) does not throw or emit a phantom
+     * empty-payload edit. Intended for incremental diff previews; the writer
+     * path should always use {@link applyTo}.
+     *
+     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * unresolvable block is silently dropped so a half-written file does not
+     * throw mid-stream.
+     */
+    applyPartialTo(text: string, blockResolver?: BlockResolver): ApplyResult;
+}
+/**
+ * A parsed hashline patch — zero or more {@link PatchSection}s, each rooted
+ * at a `¶PATH#HASH` header. Construct via {@link Patch.parse}.
+ *
+ * `Patch` is pure data: parsing is line-anchored and does not look at the
+ * filesystem. To apply a patch, hand it to {@link Patcher.apply}.
+ */
+export declare class Patch {
+    readonly sections: readonly PatchSection[];
+    private constructor();
+    /**
+     * Parse `input` into a {@link Patch}. `options.cwd` resolves absolute
+     * paths inside headers to cwd-relative form; `options.path` provides a
+     * fallback when the input lacks a header but contains hashline ops
+     * (useful for streaming previews).
+     *
+     * Consecutive sections targeting the same path are merged into a single
+     * section with concatenated diff bodies. Anchors authored against the
+     * same file snapshot must be applied as one batch; otherwise the first
+     * sub-edit shifts line numbers out from under the second's anchors and
+     * validation fails.
+     */
+    static parse(input: string, options?: SplitOptions): Patch;
+    /**
+     * Parse `input` and return only the first section. Throws if the input
+     * has zero sections. Convenience for the single-section case where the
+     * caller already knows the patch is one hunk.
+     */
+    static parseSingle(input: string, options?: SplitOptions): PatchSection;
+}
+export {};
+//# sourceMappingURL=input.d.ts.map

package/dist/hashline/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../src/hashline/input.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAgEjF,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AA+CD;;;;GAIG;AACH,wBAAgB,sCAAsC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAK7E;AAyED;;;;;GAKG;AACH,qBAAa,YAAY;;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAGV,GAAG,EAAE,UAAU;IAM3B;;;;OAIG;IACH,KAAK,IAAI;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE;IAKvD,qCAAqC;IACrC,IAAI,KAAK,IAAI,SAAS,IAAI,EAAE,CAE3B;IAED,uDAAuD;IACvD,IAAI,QAAQ,IAAI,SAAS,MAAM,EAAE,CAEhC;IAED;;;;OAIG;IACH,IAAI,mBAAmB,IAAI,OAAO,CAOjC;IAED,+EAA+E;IAC/E,kBAAkB,IAAI,SAAS,MAAM,EAAE;IAkBvC;;;;;;;;;OASG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,WAAW;IAYjE;;;;;;;;;;OAUG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,aAAa,GAAG,WAAW;CASzE;AAED;;;;;;GAMG;AACH,qBAAa,KAAK;IAChB,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAE3C,OAAO;IAIP;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,KAAK;IAK9D;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,YAAY;CAM5E"}

package/dist/hashline/input.js

@@ -0,0 +1,378 @@
+/**
+ * Top-level patch parser. Splits an authored hashline input into a list of
+ * {@link PatchSection}s, each rooted at a `¶PATH#HASH` header, then exposes
+ * a {@link Patch} class that gives lazy access to the parsed edits per
+ * section. Ported from oh-my-pi `packages/hashline/src/input.ts`.
+ *
+ * The splitter is purely lexical — it doesn't know whether a section's path
+ * actually exists. That's the patcher's job.
+ */
+import * as path from "node:path";
+import { applyEdits } from "./apply.js";
+import { resolveBlockEdits } from "./block.js";
+import { HL_FILE_HASH_LENGTH, HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./format.js";
+import { parsePatch, parsePatchStreaming } from "./parser.js";
+import { Tokenizer } from "./tokenizer.js";
+/** UTF-8 BOM (U+FEFF). Built from a code point so the source stays ASCII. */
+const BOM = String.fromCharCode(0xfeff);
+// Pure classification — single shared tokenizer is safe.
+const TOKENIZER = new Tokenizer();
+function unquoteHashlinePath(pathText) {
+    if (pathText.length < 2)
+        return pathText;
+    const first = pathText[0];
+    const last = pathText[pathText.length - 1];
+    if ((first === '"' || first === "'") && first === last)
+        return pathText.slice(1, -1);
+    return pathText;
+}
+/**
+ * Strip apply_patch-style noise that models reflexively prepend to the
+ * path. Examples observed in benchmark traces:
+ *
+ *   `Update File:foo.ts`, `Update:foo.ts`, `UpdateFile:foo.ts`,
+ *   `Update/File:foo.ts`, `Update-file:foo.ts`, `Update(File):foo.ts`,
+ *   `Update<File:foo.ts`, `Add File:foo.ts`, `Delete File:foo.ts`,
+ *   `Move to:foo.ts`, `***foo.ts`, `***Update File:foo.ts`.
+ *
+ * We strip a leading `***` (the model duplicating the header sigil) and a
+ * leading `(Update|Add|Delete|Move)[<separator>]*(File|to)?[<separator>]*:`
+ * keyword block, case-insensitive. The remaining text is the real path.
+ */
+const APPLY_PATCH_PATH_NOISE_RE = /^\*{0,3}\s*(?:(?:update|add|delete|move)[^A-Za-z0-9]*(?:file|to)?[^A-Za-z0-9]*:)?\s*\*{0,3}\s*/i;
+function stripApplyPatchPathNoise(pathText) {
+    return pathText.replace(APPLY_PATCH_PATH_NOISE_RE, "");
+}
+/**
+ * Best-effort recovery for `¶`-prefixed lines the strict tokenizer
+ * rejects. Strips apply_patch keyword noise (`Update File:`, `Update:`,
+ * etc.) and an extra leading `***` (some models emit a hybrid `¶***foo.ts`
+ * shape), then expects `PATH(#HASH)?` with no embedded whitespace.
+ * Returns `null` when no clean path can be salvaged.
+ */
+function tryParseRecoveryHeader(line, cwd) {
+    if (!line.startsWith(HL_FILE_PREFIX))
+        return null;
+    const body = stripApplyPatchPathNoise(line.slice(HL_FILE_PREFIX.length).trim());
+    if (body.length === 0)
+        return null;
+    const match = new RegExp(`^(\\S+?)(?:#([0-9A-Fa-f]{${HL_FILE_HASH_LENGTH}}))?\\s*$`).exec(body);
+    if (match === null)
+        return null;
+    const parsedPath = normalizeHashlinePath(match[1] ?? "", cwd);
+    if (parsedPath.length === 0)
+        return null;
+    return match[2] !== undefined
+        ? { path: parsedPath, fileHash: match[2].toUpperCase(), diff: "" }
+        : { path: parsedPath, diff: "" };
+}
+function normalizeHashlinePath(rawPath, cwd) {
+    const unquoted = stripApplyPatchPathNoise(unquoteHashlinePath(rawPath.trim()));
+    if (!cwd || !path.isAbsolute(unquoted))
+        return unquoted;
+    const relative = path.relative(path.resolve(cwd), path.resolve(unquoted));
+    const isWithinCwd = relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+    return isWithinCwd ? relative || "." : unquoted;
+}
+/**
+ * Parse a `¶PATH[#hash]` header line. Returns `null` for lines that do
+ * not start with `¶`. Throws the strict "Input header must be …" error
+ * when a `¶`-prefixed line fails the strict shape (so malformed paths
+ * surface immediately instead of being silently re-classified as payload).
+ */
+function parseHashlineHeaderLine(line, cwd) {
+    const trimmed = line.trimEnd();
+    if (!trimmed.startsWith(HL_FILE_PREFIX))
+        return null;
+    const token = TOKENIZER.tokenize(trimmed);
+    if (token.kind !== "header") {
+        // Recovery: try to extract a path from the raw line after stripping
+        // apply_patch noise. This handles `*** Update File:foo.ts#CB5` and
+        // the half-dozen variants models actually emit.
+        const recovered = tryParseRecoveryHeader(trimmed, cwd);
+        if (recovered !== null)
+            return recovered;
+        throw new Error(`Input header must be ${HL_FILE_PREFIX}PATH or ${HL_FILE_PREFIX}PATH${HL_FILE_HASH_SEP}TAG with a ${HL_FILE_HASH_LENGTH}-hex content-hash tag; got ${JSON.stringify(trimmed)}.`);
+    }
+    const parsedPath = normalizeHashlinePath(token.path, cwd);
+    if (parsedPath.length === 0) {
+        throw new Error(`Input header "${HL_FILE_PREFIX}" is empty; provide a file path.`);
+    }
+    return token.fileHash !== undefined
+        ? { path: parsedPath, fileHash: token.fileHash, diff: "" }
+        : { path: parsedPath, diff: "" };
+}
+function stripLeadingBlankLines(input) {
+    const stripped = input.startsWith(BOM) ? input.slice(1) : input;
+    const lines = stripped.split("\n");
+    while (lines.length > 0) {
+        const head = lines[0].replace(/\r$/, "");
+        if (head.trim().length === 0 || TOKENIZER.tokenize(head).kind === "envelope-begin") {
+            lines.shift();
+            continue;
+        }
+        break;
+    }
+    return lines.join("\n");
+}
+/**
+ * Returns true when the input contains at least one line that the tokenizer
+ * recognizes as a hashline op. Used by streaming previews to decide whether
+ * the partial input is worth treating as a hashline patch yet.
+ */
+export function containsRecognizableHashlineOperations(input) {
+    for (const line of input.split(/\r?\n/)) {
+        if (TOKENIZER.isOp(line))
+            return true;
+    }
+    return false;
+}
+function normalizeFallbackInput(input, options) {
+    const stripped = input.startsWith(BOM) ? input.slice(1) : input;
+    const hasExplicitHeader = stripped
+        .split(/\r?\n/)
+        .some((rawLine) => parseHashlineHeaderLine(rawLine, options.cwd) !== null);
+    if (hasExplicitHeader)
+        return input;
+    if (!options.path || !containsRecognizableHashlineOperations(input))
+        return input;
+    const fallbackPath = normalizeHashlinePath(options.path, options.cwd);
+    if (fallbackPath.length === 0)
+        return input;
+    return `${HL_FILE_PREFIX}${fallbackPath}\n${input}`;
+}
+function splitRawSections(input, options = {}) {
+    const stripped = stripLeadingBlankLines(normalizeFallbackInput(input, options));
+    const lines = stripped.split(/\r?\n/);
+    const firstLine = lines[0] ?? "";
+    if (parseHashlineHeaderLine(firstLine, options.cwd) === null) {
+        // Catch unified-diff hunk-header contamination on the first line so
+        // the model sees a focused error.
+        const firstTrimmed = firstLine.trimEnd();
+        if (/^@@\s+[-+]?\d+,\d+\s+[-+]?\d+,\d+\s+@@/.test(firstTrimmed)) {
+            throw new Error("unified-diff hunk header (`@@ -N,M +N,M @@`) is not valid in hashline. " +
+                "File sections start with `¶path#HASH`; use `replace`, `delete`, or `insert` ops.");
+        }
+        const preview = JSON.stringify(firstLine.slice(0, 120));
+        throw new Error(`input must begin with "${HL_FILE_PREFIX}PATH${HL_FILE_HASH_SEP}HASH" on the first non-blank line for anchored edits; got: ${preview}. ` +
+            `Example: "${HL_FILE_PREFIX}src/foo.ts${HL_FILE_HASH_SEP}0A3" then edit ops.`);
+    }
+    const sections = [];
+    let current;
+    let currentLines = [];
+    const flush = () => {
+        if (!current)
+            return;
+        const hasOps = currentLines.some((line) => line.trim().length > 0);
+        if (hasOps)
+            sections.push({ ...current, diff: currentLines.join("\n") });
+        currentLines = [];
+    };
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        const token = TOKENIZER.tokenize(line);
+        if (token.kind === "envelope-end" || token.kind === "abort")
+            break;
+        if (token.kind === "envelope-begin")
+            continue;
+        // Route every `¶`-prefixed line through parseHashlineHeaderLine so
+        // malformed headers still raise the strict "Input header must be …"
+        // diagnostic (the tokenizer alone would silently classify them as
+        // payload).
+        if (trimmed.startsWith(HL_FILE_PREFIX)) {
+            const header = parseHashlineHeaderLine(line, options.cwd);
+            if (header !== null) {
+                flush();
+                current = header;
+                currentLines = [];
+                continue;
+            }
+        }
+        currentLines.push(line);
+    }
+    flush();
+    return sections;
+}
+/**
+ * Snapshot of one section in a parsed {@link Patch}: a target file plus the
+ * lazily-parsed list of edits that should land on it. Constructed by
+ * {@link Patch.parse}; consumers usually iterate `patch.sections` rather
+ * than build these directly.
+ */
+export class PatchSection {
+    path;
+    fileHash;
+    diff;
+    #parsed;
+    constructor(raw) {
+        this.path = raw.path;
+        this.fileHash = raw.fileHash;
+        this.diff = raw.diff;
+    }
+    /**
+     * Parse this section's diff body. Cached: subsequent calls return the
+     * same `{ edits, warnings }` object so callers can safely call this from
+     * multiple paths (preflight, apply, diff-preview).
+     */
+    parse() {
+        this.#parsed ??= parsePatch(this.diff);
+        return this.#parsed;
+    }
+    /** Parsed edits for this section. */
+    get edits() {
+        return this.parse().edits;
+    }
+    /** Warnings emitted during parsing of this section. */
+    get warnings() {
+        return this.parse().warnings;
+    }
+    /**
+     * True when at least one edit anchors to concrete file content. Pure
+     * `insert head:` / `insert tail:` literal inserts do not count: those are
+     * safe to apply to files that don't yet exist.
+     */
+    get hasAnchorScopedEdit() {
+        return this.edits.some((edit) => {
+            if (edit.kind === "delete")
+                return true;
+            // A `replace block N:` edit is anchored to concrete content on line N.
+            if (edit.kind === "block")
+                return true;
+            return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
+        });
+    }
+    /** Anchor lines touched by this section, sorted ascending and deduplicated. */
+    collectAnchorLines() {
+        const lines = new Set();
+        for (const edit of this.edits) {
+            if (edit.kind === "delete") {
+                lines.add(edit.anchor.line);
+                continue;
+            }
+            if (edit.kind === "block") {
+                lines.add(edit.anchor.line);
+                continue;
+            }
+            if (edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor") {
+                lines.add(edit.cursor.anchor.line);
+            }
+        }
+        return [...lines].sort((a, b) => a - b);
+    }
+    /**
+     * Apply this section's edits to `text` and return the post-edit result.
+     * Pure: does no I/O, does not validate the section snapshot tag. The
+     * {@link Patcher} owns tag validation and recovery; reach for this
+     * method directly when you've already validated the file content and
+     * just want the result.
+     *
+     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * unresolvable block throws (this is the final, authoritative preview path).
+     */
+    applyTo(text, blockResolver) {
+        const { edits, warnings } = this.parse();
+        const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, { onUnresolved: "throw" });
+        const result = applyEdits(text, resolved);
+        // Preserve parse warnings so consumers don't need to call `parse()`
+        // separately.
+        const merged = warnings.length === 0 ? result.warnings : [...warnings, ...(result.warnings ?? [])];
+        return merged && merged.length > 0
+            ? { ...result, warnings: merged }
+            : { text: result.text, firstChangedLine: result.firstChangedLine };
+    }
+    /**
+     * Streaming-tolerant counterpart to {@link applyTo}. Uses
+     * {@link parsePatchStreaming} so a trailing in-flight op (no payload yet,
+     * or a per-token parse error mid-stream) does not throw or emit a phantom
+     * empty-payload edit. Intended for incremental diff previews; the writer
+     * path should always use {@link applyTo}.
+     *
+     * `blockResolver` resolves any `replace block N:` edits against `text`; an
+     * unresolvable block is silently dropped so a half-written file does not
+     * throw mid-stream.
+     */
+    applyPartialTo(text, blockResolver) {
+        const { edits, warnings } = parsePatchStreaming(this.diff);
+        const resolved = resolveBlockEdits(edits, text, this.path, blockResolver, { onUnresolved: "drop" });
+        const result = applyEdits(text, resolved);
+        const merged = warnings.length === 0 ? result.warnings : [...warnings, ...(result.warnings ?? [])];
+        return merged && merged.length > 0
+            ? { ...result, warnings: merged }
+            : { text: result.text, firstChangedLine: result.firstChangedLine };
+    }
+}
+/**
+ * A parsed hashline patch — zero or more {@link PatchSection}s, each rooted
+ * at a `¶PATH#HASH` header. Construct via {@link Patch.parse}.
+ *
+ * `Patch` is pure data: parsing is line-anchored and does not look at the
+ * filesystem. To apply a patch, hand it to {@link Patcher.apply}.
+ */
+export class Patch {
+    sections;
+    constructor(sections) {
+        this.sections = sections;
+    }
+    /**
+     * Parse `input` into a {@link Patch}. `options.cwd` resolves absolute
+     * paths inside headers to cwd-relative form; `options.path` provides a
+     * fallback when the input lacks a header but contains hashline ops
+     * (useful for streaming previews).
+     *
+     * Consecutive sections targeting the same path are merged into a single
+     * section with concatenated diff bodies. Anchors authored against the
+     * same file snapshot must be applied as one batch; otherwise the first
+     * sub-edit shifts line numbers out from under the second's anchors and
+     * validation fails.
+     */
+    static parse(input, options = {}) {
+        const raw = mergeSamePathSections(splitRawSections(input, options));
+        return new Patch(raw.map((section) => new PatchSection(section)));
+    }
+    /**
+     * Parse `input` and return only the first section. Throws if the input
+     * has zero sections. Convenience for the single-section case where the
+     * caller already knows the patch is one hunk.
+     */
+    static parseSingle(input, options = {}) {
+        const patch = Patch.parse(input, options);
+        const first = patch.sections[0];
+        if (!first)
+            throw new Error("Patch input did not produce any sections.");
+        return first;
+    }
+}
+/**
+ * Collapse consecutive or interleaved sections targeting the same path into a
+ * single section with concatenated diffs. Anchors authored against the same
+ * file snapshot must be applied as one batch; otherwise the first sub-edit
+ * shifts line numbers out from under the second's anchors and validation
+ * fails. Path order is preserved by first occurrence.
+ */
+function mergeSamePathSections(sections) {
+    const byPath = new Map();
+    for (const section of sections) {
+        const existing = byPath.get(section.path);
+        if (existing) {
+            if (existing.fileHash !== undefined &&
+                section.fileHash !== undefined &&
+                existing.fileHash !== section.fileHash) {
+                throw new Error(`Conflicting hashline snapshot tags for ${section.path}: #${existing.fileHash} and #${section.fileHash}. Re-read the file and retry with one current header.`);
+            }
+            if (existing.fileHash === undefined && section.fileHash !== undefined)
+                existing.fileHash = section.fileHash;
+            existing.diffs.push(section.diff);
+            continue;
+        }
+        byPath.set(section.path, {
+            ...(section.fileHash !== undefined ? { fileHash: section.fileHash } : {}),
+            diffs: [section.diff],
+        });
+    }
+    return Array.from(byPath, ([sectionPath, entry]) => ({
+        path: sectionPath,
+        ...(entry.fileHash !== undefined ? { fileHash: entry.fileHash } : {}),
+        diff: entry.diffs.join("\n"),
+    }));
+}
+//# sourceMappingURL=input.js.map