jeopi-hashline 16.2.13 → 16.2.14

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## [Unreleased]
 
+## [16.2.14] - 2026-07-02
+
 ### Changed
 
 - Optimized stale-anchor remap validation from quadratic to linear complexity, significantly improving performance on large files.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-hashline",
-	"version": "16.2.13",
+	"version": "16.2.14",
 	"description": "Hashline: a compact, line-anchored patch language and applier. Pluggable FS/IO so it works over disk, in-memory, or any custom backend.",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -33,11 +33,11 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"diff": "^9.0.0",
-		"lru-cache": "11.5.1"
+		"diff": "catalog:",
+		"lru-cache": "catalog:"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3.14"
+		"@types/bun": "catalog:"
 	},
 	"engines": {
 		"bun": ">=1.3.14"

package/dist/types/apply.d.ts

@@ -1,10 +0,0 @@
-import type { ApplyResult, Edit } from "./types";
-/** A line that is nothing but closing delimiters: `}`, `)`, `];`, `})`, `},`. */
-export declare const STRUCTURAL_CLOSER_RE: RegExp;
-/**
- * Apply a parsed list of edits to a text body. Pure function — no I/O.
- *
- * Returns the post-edit text and the first changed line number (1-indexed).
- * Throws if an anchor is out of bounds.
- */
-export declare function applyEdits(text: string, edits: readonly Edit[]): ApplyResult;

package/dist/types/block.d.ts

@@ -1,39 +0,0 @@
-import type { BlockResolution, BlockResolver, Edit } from "./types";
-export interface ResolveBlockEditsOptions {
-    /**
-     * How to handle a replace/delete block edit that cannot be resolved
-     * (missing resolver or a `null` span). `"throw"` (default) raises a
-     * `blockUnresolvedMessage` error — used by the authoritative apply + final
-     * preview paths. `"drop"` silently skips the edit — used by the streaming
-     * preview, where a half-written file or transient parse error must not
-     * throw. Unresolvable `insert_after_block N:` edits never reach this: they
-     * are lowered to plain `insert after N:` with a warning.
-     */
-    onUnresolved?: "throw" | "drop";
-    /**
-     * Invoked once per successfully resolved block edit, in patch order, with
-     * the anchor line and the concrete span it resolved to. Lets the host echo
-     * the resolution back to the caller. Never fired for dropped/unresolvable
-     * edits.
-     */
-    onResolved?: (resolution: BlockResolution) => void;
-    /**
-     * Invoked once per diagnostic produced while resolving — currently the
-     * `insert_after_block N:` lowerings (closer anchor or unresolvable block).
-     * Hosts should surface these on the apply result's `warnings`.
-     */
-    onWarning?: (message: string) => void;
-}
-/** True when at least one edit is an unresolved deferred block edit. */
-export declare function hasBlockEdit(edits: readonly Edit[]): boolean;
-/**
- * Resolve every deferred block edit in `edits` against `text` (parsed as the
- * language inferred from `path`). Non-block edits pass through untouched.
- * Returns a fresh edit list with no `block` variants. The fast path returns the
- * input unchanged when there is nothing to resolve.
- *
- * Synthesized inserts/deletes carry sequential `index` values for readability
- * only — {@link applyEdits} re-derives every edit's index from array order, so
- * the passthrough edits keeping their original indices is harmless.
- */
-export declare function resolveBlockEdits(edits: readonly Edit[], text: string, path: string, resolver: BlockResolver | undefined, options?: ResolveBlockEditsOptions): readonly Edit[];

package/dist/types/diff-preview.d.ts

@@ -1,14 +0,0 @@
-/**
- * Re-number a unified diff that uses the `+<lineNum>|content` /
- * `-<lineNum>|content` / ` <lineNum>|content` line format into a compact
- * current-file preview. Removed lines are counted for stats and post-edit
- * offset tracking, but omitted from the preview. Added and context lines are
- * anchored to their post-edit positions so a follow-up edit can reuse visible
- * concrete lines directly. Long contiguous added runs are summarized with a
- * `…` marker instead of echoing every inserted line.
- *
- * This is intentionally decoupled from the diff producer: anything that
- * emits the `<sign><lineNum>|<content>` shape works.
- */
-import type { CompactDiffOptions, CompactDiffPreview } from "./types";
-export declare function buildCompactDiffPreview(diff: string, options?: CompactDiffOptions): CompactDiffPreview;

package/dist/types/format.d.ts

@@ -1,83 +0,0 @@
-/**
- * Hashline format primitives: sigils, separators, regex fragments, and
- * display helpers. These are the single source of truth for the parser, the
- * tokenizer, the prompt, and the formal grammar.
- */
-import type { Cursor } from "./types";
-/** File-section header delimiters: `[path#hash]`. */
-export declare const HL_FILE_PREFIX = "[";
-export declare const HL_FILE_SUFFIX = "]";
-/** Payload sigil for literal body rows. */
-export declare const HL_PAYLOAD_REPLACE = "+";
-/** Hunk-header keyword for concrete line replacement. */
-export declare const HL_REPLACE_KEYWORD = "SWAP";
-/** Hunk-header keyword for concrete line deletion. */
-export declare const HL_DELETE_KEYWORD = "DEL";
-/** Hunk-header keyword for insertion operations. */
-export declare const HL_INSERT_KEYWORD = "INS";
-/** Insert position keyword for inserting before a concrete line. */
-export declare const HL_INSERT_BEFORE = "PRE";
-/** Insert position keyword for inserting after a concrete line. */
-export declare const HL_INSERT_AFTER = "POST";
-/** Insert position keyword for inserting at the start of the file. */
-export declare const HL_INSERT_HEAD = "HEAD";
-/** Insert position keyword for inserting at the end of the file. */
-export declare const HL_INSERT_TAIL = "TAIL";
-/** Hunk-header keyword: `SWAP.BLK N:` resolves N to a tree-sitter block range and replaces its span. */
-export declare const HL_REPLACE_BLOCK_KEYWORD = "SWAP.BLK";
-/** Hunk-header keyword: `DEL.BLK N` resolves N to a tree-sitter block range and deletes its span. */
-export declare const HL_DELETE_BLOCK_KEYWORD = "DEL.BLK";
-/** Hunk-header keyword: `INS.BLK.POST N:` inserts after the last line of the tree-sitter block at N. */
-export declare const HL_INSERT_AFTER_BLOCK_KEYWORD = "INS.BLK.POST";
-/** File-level keyword: `REM` deletes the whole file named by the section header. */
-export declare const HL_REM_KEYWORD = "REM";
-/** File-level keyword: `MV DEST` renames/moves the section file to `DEST`. */
-export declare const HL_MOVE_KEYWORD = "MV";
-export declare const HL_HEADER_COLON = ":";
-/** Separator between a hashline file path and its opaque snapshot tag. */
-export declare const HL_FILE_HASH_SEP = "#";
-/** Separator between two line numbers in a range, e.g. `5.=10`. */
-export declare const HL_RANGE_SEP = ".=";
-/** Separator between a line number and displayed line content in hashline mode. */
-export declare const HL_LINE_BODY_SEP = ":";
-/** Bare positive line-number Lid (no decorations, no captures, no anchors). */
-export declare const HL_LINE_RE_RAW = "[1-9]\\d*";
-/** Capture-group form of {@link HL_LINE_RE_RAW}. */
-export declare const HL_LINE_CAPTURE_RE_RAW = "([1-9]\\d*)";
-/** Format a concrete replacement hunk header. */
-export declare function formatReplaceHeader(start: number, end: number): string;
-/** Format a concrete deletion hunk header. */
-export declare function formatDeleteHeader(start: number, end?: number): string;
-/** Format an insertion hunk header for a cursor position. */
-export declare function formatInsertHeader(cursor: Cursor): string;
-/** Number of hex characters in a content-derived file-hash tag. */
-export declare const HL_FILE_HASH_LENGTH = 4;
-/** Canonical uppercase hexadecimal content-hash tag carried by a hashline section header. */
-export declare const HL_FILE_HASH_RE_RAW = "[0-9A-F]{4}";
-/** Capture-group form of {@link HL_FILE_HASH_RE_RAW}. */
-export declare const HL_FILE_HASH_CAPTURE_RE_RAW = "([0-9A-F]{4})";
-/** Regex-escaped form of {@link HL_LINE_BODY_SEP}, safe for embedding inside a regex. */
-export declare const HL_LINE_BODY_SEP_RE_RAW: string;
-/**
- * Representative file-hash tags for use in user-facing error messages and
- * prompt examples.
- */
-export declare const HL_FILE_HASH_EXAMPLES: readonly ["1A2B", "3C4D", "9F3E"];
-/**
- * Compute the content-derived hash tag carried by a hashline section header.
- * The tag is a 4-hex fingerprint of the whole file's normalized text: any read
- * of byte-identical content mints the same tag, and a follow-up edit anchored
- * at any line validates whenever the live file still hashes to it.
- */
-export declare function computeFileHash(text: string): string;
-/**
- * Format a comma-separated list of example anchors with an optional line-number
- * prefix, quoted for inclusion in error messages: `"160", "42", "7"`.
- */
-export declare function describeAnchorExamples(linePrefix?: string): string;
-/** Format a hashline section header for a file path and snapshot tag. */
-export declare function formatHashlineHeader(filePath: string, fileHash: string): string;
-/** Formats a single numbered line as `LINE:TEXT`. */
-export declare function formatNumberedLine(lineNumber: number, line: string): string;
-/** Format file text with hashline-mode line-number prefixes for display. */
-export declare function formatNumberedLines(text: string, startLine?: number): string;

package/dist/types/fs.d.ts

@@ -1,109 +0,0 @@
-/**
- * Result returned by {@link Filesystem.writeText}. The patcher echoes back
- * `text` so adapters that transform on serialization (e.g. notebooks) can
- * report what actually landed on disk.
- */
-export interface WriteResult {
-    /** Final text that was persisted. May differ from the input if the FS transformed it. */
-    text: string;
-}
-import type { FileOp } from "./types";
-/** Optional hints for {@link Filesystem.preflightWrite}. */
-export interface PreflightWriteOptions {
-    fileOp?: FileOp;
-}
-/**
- * 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 declare class NotFoundError extends Error {
-    readonly code = "ENOENT";
-    constructor(path: string, cause?: unknown);
-}
-/** Type guard for {@link NotFoundError} and structurally-compatible errors. */
-export declare function isNotFound(error: unknown): boolean;
-/**
- * Abstract storage backend the {@link Patcher} reads from and writes to.
- * Subclass for new backends; the package ships {@link InMemoryFilesystem} and
- * {@link NodeFilesystem} for the most common cases.
- *
- * 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 declare abstract class Filesystem {
-    /** Read the file's full text content. Throw on missing file. */
-    abstract readText(path: string): Promise<string>;
-    /** Read raw bytes for backends whose text is a direct decode of persisted bytes. */
-    readBinary?(path: string): Promise<Uint8Array | undefined>;
-    /** Validate that `path` is writable before a prepared batch starts committing. */
-    preflightWrite(_path: string, _options?: PreflightWriteOptions): Promise<void>;
-    /** Persist `content` at `path`. Returns the actual final text that was written. */
-    abstract writeText(path: string, content: string): Promise<WriteResult>;
-    /** Delete the file at `path`. Default: not supported. */
-    delete(path: string): Promise<void>;
-    /**
-     * Move/rename `from` to `to`. When `content` is provided the destination
-     * receives that text; otherwise implementations may preserve the source bytes.
-     */
-    move(from: string, to: string, content?: string): Promise<void>;
-    /** Return true when the path exists and can be read. Default: probe via {@link readText}. */
-    exists(path: string): Promise<boolean>;
-    /**
-     * 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: string): string;
-    /**
-     * Whether a section whose authored path is missing may be redirected to
-     * the file its snapshot tag names (tag-based path recovery in
-     * {@link Patcher.prepare}). `resolvedPath` is the canonical path the
-     * redirect would read and write. Default: allow.
-     *
-     * Hosts that grant write privileges by path shape override this to refuse
-     * redirects that could escalate beyond what the caller approved — e.g. an
-     * internal-URL authored target (approved read-only), or a `resolvedPath`
-     * outside the working tree (a sandbox/vault/out-of-tree write).
-     */
-    allowTagPathRecovery(_authoredPath: string, _resolvedPath: string): boolean;
-}
-/**
- * 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 declare class InMemoryFilesystem extends Filesystem {
-    #private;
-    constructor(initial?: Iterable<readonly [string, string]>);
-    readText(path: string): Promise<string>;
-    writeText(path: string, content: string): Promise<WriteResult>;
-    delete(path: string): Promise<void>;
-    move(from: string, to: string, content?: string): Promise<void>;
-    exists(path: string): Promise<boolean>;
-    /** Synchronous helper for setting up fixtures without awaiting. */
-    set(path: string, content: string): void;
-    /** Synchronous helper for inspecting state without awaiting. */
-    get(path: string): string | undefined;
-    /** Wipe all entries. */
-    clear(): void;
-    /** Iterate `[path, content]` pairs. */
-    entries(): IterableIterator<[string, string]>;
-}
-/**
- * Disk-backed {@link Filesystem} using Bun's file APIs. The default for CLI
- * use. Paths are accepted as-is; callers responsible for any cwd or
- * jail/sandbox resolution should wrap this with their own subclass.
- */
-export declare class NodeFilesystem extends Filesystem {
-    readText(path: string): Promise<string>;
-    readBinary(path: string): Promise<Uint8Array>;
-    writeText(path: string, content: string): Promise<WriteResult>;
-    delete(path: string): Promise<void>;
-    move(from: string, to: string, content?: string): Promise<void>;
-    canonicalPath(path: string): string;
-    exists(path: string): Promise<boolean>;
-}

package/dist/types/index.d.ts

@@ -1,17 +0,0 @@
-export * from "./apply";
-export * from "./block";
-export * from "./diff-preview";
-export * from "./format";
-export * from "./fs";
-export * from "./input";
-export * from "./messages";
-export * from "./mismatch";
-export * from "./normalize";
-export * from "./parser";
-export * from "./patcher";
-export * from "./prefixes";
-export * from "./recovery";
-export * from "./snapshots";
-export * from "./stream";
-export * from "./tokenizer";
-export * from "./types";

package/dist/types/input.d.ts

@@ -1,110 +0,0 @@
-import type { ApplyResult, BlockResolver, Edit, FileOp, SplitOptions } from "./types";
-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, fileOp?, warnings }` object so callers can safely call this from
-     * multiple paths (preflight, apply, diff-preview).
-     */
-    parse(): {
-        edits: Edit[];
-        fileOp?: FileOp;
-        warnings: readonly string[];
-    };
-    /** Parsed edits for this section. */
-    get edits(): readonly Edit[];
-    /** Optional whole-file operation (`REM` / `MV`). */
-    get fileOp(): FileOp | undefined;
-    /** 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 copy of this section rebound to a different target `path`, preserving
-     * the snapshot tag, diff body, and any cached parse result. Used by the
-     * patcher's tag-based path recovery to redirect an edit whose authored
-     * path does not exist onto the file its snapshot tag actually names.
-     */
-    withPath(path: string): PatchSection;
-}
-/**
- * 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 {};

package/dist/types/messages.d.ts

@@ -1,127 +0,0 @@
-/** Centralized error/warning text for the hashline parser, applier, and patcher. */
-/** Lines of context shown either side of a hash mismatch. */
-export declare const MISMATCH_CONTEXT = 2;
-/**
- * Numbered `LINE:TEXT` rows around `anchorLines` (±{@link MISMATCH_CONTEXT}),
- * `*`-marking anchors, `...` between non-adjacent runs. Out-of-range anchors
- * contribute no rows.
- */
-export declare function formatAnchoredContext(anchorLines: readonly number[], fileLines: readonly string[]): string[];
-/** Optional patch envelope start marker; silently consumed. */
-export declare const BEGIN_PATCH_MARKER = "*** Begin Patch";
-/** Optional patch envelope end marker; terminates parsing. */
-export declare const END_PATCH_MARKER = "*** End Patch";
-/**
- * Truncation sentinel emitted by an agent loop mid-call. Ends parsing like
- * {@link END_PATCH_MARKER}, without a warning.
- */
-export declare const ABORT_MARKER = "*** Abort";
-/** Two consecutive hunks targeted the exact same concrete range. */
-export declare const REPLACE_PAIR_COALESCED_WARNING = "Two hunks targeted the same range; kept only the second. One `SWAP N.=M:` hunk per range \u2014 the body is the final content, never old+new.";
-/** Bare body rows auto-converted to literal `+` rows. */
-export declare const BARE_BODY_AUTO_PIPED_WARNING = "Auto-prefixed bare body row(s) with `+`. Body rows must be `+TEXT` literal lines.";
-/** Unified-diff-style `-` row in a hunk body. */
-export declare const MINUS_ROW_REJECTED = "`-` rows are not valid; the range already names the lines being changed. For Markdown bullets or other literal `-` lines, prefix the literal row with `+`: `+- item`.";
-/** Replace hunk with no body. */
-export declare const EMPTY_REPLACE = "`SWAP N.=M:` needs at least one `+TEXT` body row. To delete lines, use `DEL N.=M`.";
-/** `replace_block N:` hunk with no body. */
-export declare const EMPTY_BLOCK = "`SWAP.BLK N:` needs at least one `+TEXT` body row. To delete a block, use `DEL.BLK N`.";
-/**
- * Block-anchored replace/delete could not resolve to a syntactic block
- * (unsupported language, blank/out-of-range line, no node beginning on N, or
- * parse error). Appends a {@link formatAnchoredContext} preview when
- * `fileLines` is given. `insert_after_block N:` never reaches this — it is
- * lowered to plain `insert after N:` instead (see
- * {@link insertAfterBlockUnresolvedLoweredWarning}).
- */
-export declare function blockUnresolvedMessage(line: number, op?: "replace" | "delete", fileLines?: readonly string[]): string;
-/** Block-anchored edit reached a path with no {@link BlockResolver} wired in — a host-configuration bug. */
-export declare const BLOCK_RESOLVER_UNAVAILABLE = "`SWAP.BLK`/`DEL.BLK`/`INS.BLK.POST` are not available here (no block resolver configured). Use a concrete line range.";
-/**
- * `insert_after_block N:` anchored on a closing-delimiter line, lowered to
- * plain `insert after N:` — the closer ends a block, and inserting after it
- * is exactly what the plain form does.
- */
-export declare function insertAfterBlockCloserLoweredWarning(line: number): string;
-/**
- * `insert_after_block N:` anchor unresolvable (unsupported language, blank
- * line, parse error, or no resolver), lowered to plain `insert after N:` —
- * applying with a warning beats failing the patch.
- */
-export declare function insertAfterBlockUnresolvedLoweredWarning(line: number): string;
-/**
- * Internal invariant: `applyEdits` received an unresolved `replace_block N:`
- * edit; `resolveBlockEdits` must run first. Wiring bug, not authored input.
- */
-export declare const UNRESOLVED_BLOCK_INTERNAL = "internal error: unresolved `SWAP.BLK` edit reached the applier (resolveBlockEdits was not run).";
-/** Delete hunk received a body row. */
-export declare const DELETE_TAKES_NO_BODY = "`DEL N.=M` does not take body rows. Remove the body, or use `SWAP N.=M:`.";
-/** `REM` received a body row or coexists with line edits. */
-export declare const REM_TAKES_NO_BODY = "`REM` deletes the whole file and takes no body rows or line ops. Issue it alone under the header.";
-/** `MV` received a body row. */
-export declare const MOVE_TAKES_NO_BODY = "`MV DEST` does not take body rows. Put line edits above the `MV` row; the destination path follows `MV` on the same line.";
-/** `delete_block N` hunk received a body row. */
-export declare const DELETE_BLOCK_TAKES_NO_BODY = "`DEL.BLK N` does not take body rows. Remove the body, or use `SWAP.BLK N:`.";
-/** Insert hunk with no body. */
-export declare const EMPTY_INSERT = "`INS` needs at least one `+TEXT` body row.";
-/**
- * `insert after` body indented shallower than the anchor: the landing slid
- * forward past trailing closer lines — the common "anchored on the last line
- * I read instead of after the block" mistake.
- */
-export declare function afterInsertLandingShiftWarning(anchorLine: number, landingLine: number, crossed: number): string;
-/**
- * `insert_after_block N:` body indented deeper than the block's closer: the
- * landing was pulled inside the block — a deeper body almost always means
- * "append inside the block's body".
- */
-export declare function blockInsertLandingShiftWarning(blockStart: number, closerLine: number, landingLine: number): string;
-/** `Recovery`: an external write matched a cached snapshot. */
-export declare const RECOVERY_EXTERNAL_WARNING = "Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
-/** `Recovery`: a prior in-session edit advanced the hash. */
-export declare const RECOVERY_SESSION_CHAIN_WARNING = "Recovered from a stale file hash using an earlier in-session snapshot (a prior edit in this session advanced the hash).";
-/**
- * `Recovery`: session-chain replay fast-path. Less certain than
- * {@link RECOVERY_SESSION_CHAIN_WARNING} — the 3-way merge refused, the
- * anchor-content gate passed, but a coincidental insert+delete earlier in
- * the chain could still misplace an anchor — hence the verify hedge.
- */
-export declare const RECOVERY_SESSION_REPLAY_WARNING = "Recovered by replaying your edits onto the current file content (a prior in-session edit changed the lines you re-targeted with a stale hash). Verify the diff matches your intent.";
-/** `Recovery`: stale anchors were relocated to unchanged live lines after drift. */
-export declare const RECOVERY_LINE_REMAP_WARNING = "Recovered by remapping stale line anchors to unchanged current lines (file changed since the tagged read). Verify the diff matches your intent.";
-/**
- * `insert head:`/`insert tail:` applied despite a stale snapshot tag.
- * Head/tail position is content-independent, so drift is non-fatal: apply
- * onto live content and warn instead of hard-failing.
- */
-export declare const HEADTAIL_DRIFT_WARNING = "Applied the `INS.HEAD:`/`INS.TAIL:` edit despite a stale snapshot tag (file changed since your read) \u2014 head/tail position is content-independent. Re-read if the drift was unexpected.";
-/**
- * Section omitted the mandatory snapshot tag. Shared by the apply
- * ({@link Patcher.prepare}) and preview/diff paths so both stay in lockstep.
- */
-export declare function missingSnapshotTagMessage(sectionPath: string): string;
-/**
- * A section named a path that does not exist, but its filename and snapshot
- * tag together match exactly one file read earlier this session — the model
- * gave the bare filename (or wrong directory) for a file it just read. The
- * edit was rebound to that file's full path. Surfaced as a warning so the
- * model (and user) learn the corrected path and stop reusing the wrong one.
- */
-export declare function pathRecoveredFromTagMessage(authoredPath: string, resolvedPath: string, tag: string): string;
-/**
- * An anchored edit referenced lines the read that minted the cited tag never
- * displayed (a partial range, or a structural summary that collapsed bodies).
- * Editing lines you have not read is the off-by-memory failure that mangles
- * files; reject and make the model re-read those exact lines first.
- */
-export declare function unseenLinesMessage(sectionPath: string, unseenLines: readonly number[], tag: string): string;
-/** Op kind of a deferred block edit, for {@link blockSingleLineMessage}. */
-export type BlockOp = "replace" | "delete" | "insert_after";
-/**
- * A `replace_block`/`delete_block`/`insert_after_block` anchor resolved to a
- * single line — almost always a bare statement the model mis-anchored, not a
- * multi-line construct. The plain op is unambiguous for one line; the block
- * form only earns its keep when it spares counting a closing line you cannot
- * see. Reject and point at both fixes.
- */
-export declare function blockSingleLineMessage(line: number, op: BlockOp): string;

package/dist/types/mismatch.d.ts

@@ -1,44 +0,0 @@
-/** Format the required-shape diagnostic shown when a line reference is malformed. */
-export declare function formatFullAnchorRequirement(raw?: string): string;
-/** Parse a decorated bare line-number anchor like `42`, `*42:foo`, ` > 7`. */
-export declare function parseTag(ref: string): {
-    line: number;
-};
-export interface MismatchDetails {
-    path?: string;
-    expectedFileHash: string;
-    actualFileHash: string;
-    fileLines: string[];
-    anchorLines?: readonly number[];
-    /**
-     * `true` when the section's expected hash resolved to a recorded snapshot
-     * (file content drifted since that snapshot), `false` when no snapshot
-     * was ever recorded for the hash (likely fabricated or carried over from
-     * a prior session). Drives a more actionable rejection message; defaults
-     * to `true` for backward compatibility with direct callers.
-     */
-    hashRecognized?: boolean;
-}
-/**
- * Raised when a hashline section's snapshot tag doesn't match the live file's
- * content (and recovery, if configured, declined the merge). Carries the
- * file lines plus anchored lines so renderers can produce a richer
- * diagnostic via {@link MismatchError.displayMessage}.
- */
-export declare class MismatchError extends Error {
-    readonly path: string | undefined;
-    readonly expectedFileHash: string;
-    readonly actualFileHash: string;
-    readonly fileLines: string[];
-    readonly anchorLines: readonly number[];
-    readonly hashRecognized: boolean;
-    constructor(details: MismatchDetails);
-    get displayMessage(): string;
-    static rejectionHeader(details: MismatchDetails): string[];
-    static formatDisplayMessage(details: MismatchDetails): string;
-    static formatMessage(details: MismatchDetails): string;
-}
-/** Throws when the line reference is out of bounds for the given file. */
-export declare function validateLineRef(ref: {
-    line: number;
-}, fileLines: string[]): void;

package/dist/types/normalize.d.ts

@@ -1,20 +0,0 @@
-/**
- * Minimal text-shape normalization: line-ending detection / round-trip and
- * BOM stripping. The patcher uses these to canonicalize text to LF before
- * applying edits and to restore the original shape on write-back.
- */
-export type LineEnding = "\r\n" | "\n";
-/** Detect the first line ending style in `content`. Defaults to LF when neither is present. */
-export declare function detectLineEnding(content: string): LineEnding;
-/** Normalize every line ending to LF. */
-export declare function normalizeToLF(text: string): string;
-/** Re-encode LF text with the requested line ending. */
-export declare function restoreLineEndings(text: string, ending: LineEnding): string;
-export interface BomResult {
-    /** Either the empty string or the BOM sequence (currently UTF-8 BOM). */
-    bom: string;
-    /** Text with any leading BOM removed. */
-    text: string;
-}
-/** Strip a UTF-8 BOM if present and return both the BOM and the trailing text. */
-export declare function stripBom(content: string): BomResult;

package/dist/types/parser.d.ts

@@ -1,27 +0,0 @@
-import { type Token } from "./tokenizer";
-import type { Edit, FileOp } from "./types";
-export declare class Executor {
-    #private;
-    feed(token: Token): void;
-    end(): {
-        edits: Edit[];
-        fileOp?: FileOp;
-        warnings: string[];
-    };
-    endStreaming(): {
-        edits: Edit[];
-        fileOp?: FileOp;
-        warnings: string[];
-    };
-    reset(): void;
-}
-export declare function parsePatch(diff: string): {
-    edits: Edit[];
-    fileOp?: FileOp;
-    warnings: string[];
-};
-export declare function parsePatchStreaming(diff: string): {
-    edits: Edit[];
-    fileOp?: FileOp;
-    warnings: string[];
-};

package/dist/types/patcher.d.ts

@@ -1,118 +0,0 @@
-import type { Filesystem } from "./fs";
-import type { Patch, PatchSection } from "./input";
-import { type LineEnding } from "./normalize";
-import { Recovery } from "./recovery";
-import type { SnapshotStore } from "./snapshots";
-import type { ApplyResult, BlockResolution, BlockResolver, FileOp } from "./types";
-export interface PatcherOptions {
-    /** Storage backend used for all reads and writes. */
-    fs: Filesystem;
-    /** Snapshot store that minted and resolves hashline section tags. Required. */
-    snapshots: SnapshotStore;
-    /**
-     * Resolves `replace_block N:` anchors to concrete line spans via tree-sitter.
-     * Optional: when omitted, any `replace_block N:` edit throws on apply (the
-     * host did not wire a resolver). Plain line-range ops never need it.
-     */
-    blockResolver?: BlockResolver;
-}
-/** Per-section result returned by {@link Patcher.apply} / {@link Patcher.commit}. */
-export interface PatchSectionResult {
-    /** Section path (as authored, after cwd-resolution at parse time). */
-    path: string;
-    /** Filesystem-canonical key for this section (e.g. absolute path). */
-    canonicalPath: string;
-    /** `"noop"` when the apply produced no change; `"delete"` removes the file; otherwise `"create"` / `"update"`. */
-    op: "create" | "update" | "delete" | "noop";
-    /** Pre-edit text (LF-normalized, BOM-stripped). */
-    before: string;
-    /** Post-edit text (LF-normalized, BOM-stripped). For `"noop"` equals `before`. */
-    after: string;
-    /** Same text as `after` but with the original BOM and line ending restored. */
-    persisted: string;
-    /** Final text that the {@link Filesystem} actually wrote (may differ if the FS transformed it). */
-    written: string;
-    /** 4-hex content-hash tag for `after`. Use to anchor follow-up edits. */
-    fileHash: string;
-    /** Hashline section header (`[path#tag]`) of the post-edit content. */
-    header: string;
-    /** 1-indexed first changed line in `after`, or `undefined` for noops. */
-    firstChangedLine?: number;
-    /** Warnings collected by the parser, applier, and (optionally) recovery. */
-    warnings: string[];
-    /** Destination path when this section includes `MV DEST`. */
-    moveDest?: string;
-    /**
-     * Resolved spans for any `replace_block`/`delete_block` ops, present when the
-     * apply matched the tagged content. Undefined for patches with no block ops
-     * (and for resolutions routed through drift recovery, where numbers shift).
-     */
-    blockResolutions?: BlockResolution[];
-}
-export interface PatcherApplyResult {
-    sections: PatchSectionResult[];
-}
-/**
- * Opaque token returned by {@link Patcher.prepare}. Carries the section, the
- * raw file content read off disk, and the in-memory apply result.
- * {@link Patcher.commit} just writes the {@link PreparedSection.applyResult}.
- */
-export declare class PreparedSection {
-    readonly section: PatchSection;
-    readonly canonicalPath: string;
-    readonly exists: boolean;
-    readonly rawContent: string;
-    readonly bom: string;
-    readonly lineEnding: LineEnding;
-    readonly normalized: string;
-    readonly applyResult: ApplyResult;
-    readonly parseWarnings: readonly string[];
-    readonly fileOp: FileOp | undefined;
-    /** @internal */
-    constructor(section: PatchSection, canonicalPath: string, exists: boolean, rawContent: string, bom: string, lineEnding: LineEnding, normalized: string, applyResult: ApplyResult, parseWarnings: readonly string[], fileOp: FileOp | undefined);
-    /** Convenience: returns true when the apply produced no change and no file op. */
-    get isNoop(): boolean;
-}
-/**
- * High-level patcher. Wires a {@link Filesystem} and a required
- * {@link SnapshotStore} together with the parsing + applying core.
- *
- * Construct once per FS configuration; reuse across patches.
- */
-export declare class Patcher {
-    #private;
-    readonly fs: Filesystem;
-    readonly snapshots: SnapshotStore;
-    readonly recovery: Recovery;
-    readonly blockResolver: BlockResolver | undefined;
-    constructor(options: PatcherOptions);
-    /**
-     * Apply every section in `patch`. `prepare` runs the full apply for each
-     * section in memory before any write hits the filesystem, so a
-     * multi-section batch is naturally all-or-nothing. Returns one
-     * {@link PatchSectionResult} per section in the original patch order.
-     */
-    apply(patch: Patch): Promise<PatcherApplyResult>;
-    /**
-     * Run the preflight pass only: read, parse, validate, apply-in-memory.
-     * No writes hit the filesystem. Use for CI checks and dry runs.
-     */
-    preflight(patch: Patch): Promise<void>;
-    /**
-     * Read a section's target file, parse the section, validate the snapshot
-     * tag (with recovery), and apply the edits in memory. Returns a
-     * {@link PreparedSection} which can be fed to {@link commit} to land
-     * the result on the filesystem.
-     *
-     * Throws on parse error, missing-file-for-anchored-edit, or unrecovered
-     * tag mismatch ({@link MismatchError}).
-     */
-    prepare(section: PatchSection): Promise<PreparedSection>;
-    /**
-     * Commit a previously {@link prepare}d section to the filesystem.
-     * Restores line endings and BOM, writes via the {@link Filesystem}, and
-     * records a fresh snapshot in the {@link SnapshotStore} keyed by the
-     * filesystem-canonical path.
-     */
-    commit(prepared: PreparedSection): Promise<PatchSectionResult>;
-}

package/dist/types/prefixes.d.ts

@@ -1,42 +0,0 @@
-/**
- * When a hashline payload is authored against `read`/`search` output, each
- * line is prefixed with either a hashline-mode line number (`123:`) or, for
- * diff-style echoes, a leading `+`. These helpers detect that and recover
- * the raw text. Two strip modes are exposed:
- *
- * - {@link stripNewLinePrefixes} — opportunistic: strips when the input
- *   clearly carries hashline or diff prefixes, leaves it alone otherwise.
- * - {@link stripHashlinePrefixes} — strict: only strips when every non-empty
- *   content line is hashline-prefixed.
- *
- * These run *before* the tokenizer; they exist because hashline mode is the
- * common case for echoed file content, and erroneously echoed prefixes will
- * otherwise turn every content line into a (malformed) op.
- */
-/**
- * Single-pass variant of {@link stripLeadingHashlinePrefixes} that strips at
- * most one leading hashline prefix (`N:`, `>>>N:`, `+N:` etc.) and does NOT
- * loop. Use this when the input carries at most one snapshot prefix (e.g. a
- * bare body row paste from `read` output) — recursive stripping would corrupt
- * content whose own text starts with `digits:`.
- */
-export declare function stripOneLeadingHashlinePrefix(line: string): string;
-/**
- * Strip whichever prefix scheme the lines appear to be carrying:
- * - hashline line-number prefixes (`123:`) when every content line has one
- * - leading `+` (diff style) when at least half the lines have one
- * - mixed `+<n>:` form when present
- *
- * Returns the lines untouched if no scheme is recognized.
- */
-export declare function stripNewLinePrefixes(lines: string[]): string[];
-/**
- * Strict variant: strip hashline prefixes only when every content line is
- * hashline-prefixed. Returns the lines unchanged otherwise.
- */
-export declare function stripHashlinePrefixes(lines: string[]): string[];
-/**
- * Normalize line payloads by stripping read/search line prefixes. `null` /
- * `undefined` yield `[]`; a single multiline string is split on `\n`.
- */
-export declare function hashlineParseText(edit: string[] | string | null | undefined): string[];

package/dist/types/recovery.d.ts

@@ -1,44 +0,0 @@
-import type { SnapshotStore } from "./snapshots";
-import type { Edit } from "./types";
-export interface RecoveryArgs {
-    path: string;
-    currentText: string;
-    fileHash: string;
-    edits: readonly Edit[];
-}
-export interface RecoveryResult {
-    /** Post-recovery text. */
-    text: string;
-    /** First changed line (1-indexed) relative to the live `currentText`, or `undefined`. */
-    firstChangedLine: number | undefined;
-    /** Warnings collected during recovery, including the user-facing recovery banner. */
-    warnings: string[];
-}
-/**
- * Stateless recovery driver over a {@link SnapshotStore}. Construct once and
- * call {@link Recovery.tryRecover} per stale-tag incident. The default
- * implementation tries three strategies in order:
- *
- * 1. Apply the edits on the full-file version the tag names, then 3-way-merge
- *    the resulting patch onto the live content (handles external writes).
- * 2. Remap every stale anchor through the unchanged-line diff from the tagged
- *    snapshot to the live text, then replay on live content. This handles a
- *    prior insertion/deletion before the target while refusing changed anchors
- *    and mixed offsets across the same edit range.
- * 3. (Session chain) If that version wasn't the head, replay the edits onto
- *    the live content directly when line counts match AND every edit's anchor
- *    line content is unchanged between version and current — a prior in-session
- *    edit advanced the tag and the model's anchors still name the same logical
- *    rows. Emits a dedicated {@link RECOVERY_SESSION_REPLAY_WARNING} because
- *    even with both guards a coincidental insert+delete pair on duplicate rows
- *    can still land the edit on the wrong row; see {@link replaySessionChainOnCurrent}.
- */
-export declare class Recovery {
-    readonly store: SnapshotStore;
-    constructor(store: SnapshotStore);
-    /**
-     * Attempt recovery. Returns `null` when no path forward is found — the
-     * caller should then surface a {@link MismatchError}.
-     */
-    tryRecover(args: RecoveryArgs): RecoveryResult | null;
-}

package/dist/types/snapshots.d.ts

@@ -1,127 +0,0 @@
-/**
- * One full-file version observed at a point in time. The tag the model sees is
- * {@link Snapshot.hash}; recovery replays edits against {@link Snapshot.text}.
- */
-export interface Snapshot {
-    /** Canonical path this version belongs to. */
-    readonly path: string;
-    /** Full normalized (LF, no BOM) file text as observed. */
-    readonly text: string;
-    /** Content-derived tag for {@link Snapshot.text} (see {@link computeFileHash}). */
-    readonly hash: string;
-    /** Timestamp (ms since epoch) the version was recorded. */
-    recordedAt: number;
-    /**
-     * 1-indexed file lines a producer (read/search) actually *displayed* under
-     * this tag. A partial read (range, or a structural summary that collapsed
-     * bodies) leaves this sparse; a whole-file read fills every line. Multiple
-     * reads of the same content union into one set. `undefined` means "no
-     * provenance recorded" — the patcher then skips the seen-line check and
-     * applies as before. Mutated in place as more of the same content is read.
-     */
-    seenLines?: Set<number>;
-}
-/**
- * Storage seam for full-file version snapshots. The patcher calls {@link head}
- * for the latest version of a path and {@link byHashExact} when it needs the
- * specific historical version a section's stale tag names.
- */
-export declare abstract class SnapshotStore {
-    /** Most-recently recorded version for `path`, or `null` if none. */
-    abstract head(path: string): Snapshot | null;
-    /**
-     * Recorded version for `path` whose tag equals `hash`, or `null`. When two
-     * distinct texts collide on the 16-bit tag, returns the most-recently
-     * recorded one; callers that treat the tag as content identity must use
-     * {@link byHashExact} (or verify {@link Snapshot.text} via {@link byContent}).
-     */
-    abstract byHash(path: string, hash: string): Snapshot | null;
-    /**
-     * Collision-safe {@link byHash}: the single retained version for `path`
-     * whose tag equals `hash`, or `null` when none is retained OR when two or
-     * more distinct texts collide on the tag. In the collision case there is
-     * no way to know which retained text the model's line anchors were minted
-     * against, so consumers that replay anchors (recovery, previews) must
-     * refuse rather than pick one.
-     */
-    abstract byHashExact(path: string, hash: string): Snapshot | null;
-    /**
-     * Recorded version for `path` whose {@link Snapshot.text} equals `fullText`,
-     * or `null`. Disambiguates hash collisions where two distinct file states
-     * share the same 4-hex tag: the patcher consults this before taking the
-     * no-drift path so a colliding live text is never accepted as the exact
-     * snapshot the model's line anchors were minted against.
-     */
-    abstract byContent(path: string, fullText: string): Snapshot | null;
-    /**
-     * Every retained version whose tag equals `hash`, across all tracked
-     * paths. The patcher uses this to recover the intended file when a section
-     * names a path that does not exist on disk but carries a tag the store
-     * minted — the model mistyped the path of a file it read this session.
-     *
-     * The base returns no matches (recovery disabled); stores that can
-     * enumerate their contents override it to enable tag-based path recovery.
-     */
-    findByHash(_hash: string): Snapshot[];
-    /**
-     * Record the full normalized text of `path` and return its content tag.
-     * `seenLines` (optional) are the 1-indexed lines the producer displayed;
-     * they merge into {@link Snapshot.seenLines} across reads of identical text.
-     */
-    abstract record(path: string, fullText: string, seenLines?: Iterable<number>): string;
-    /**
-     * Merge `lines` into the {@link Snapshot.seenLines} of the version whose tag
-     * equals `hash`. No-op when no such version is retained (the content aged
-     * out or was overwritten). Lets producers attach displayed lines after the
-     * tag was already minted (the body is formatted after the hash is computed).
-     */
-    abstract recordSeenLines(path: string, hash: string, lines: Iterable<number>): void;
-    /** Drop the version history for a single path. */
-    abstract invalidate(path: string): void;
-    /**
-     * Move retained version history (and read provenance) from `from` to `to`.
-     * No-op when `from` has no history. Used by file moves so tags minted from
-     * reads of the source path stay valid at the destination.
-     */
-    abstract relocate(from: string, to: string): void;
-    /** Drop every version history. */
-    abstract clear(): void;
-}
-export interface InMemorySnapshotStoreOptions {
-    /** Maximum number of distinct paths tracked at once (default 30). LRU eviction. */
-    maxPaths?: number;
-    /** Maximum full-file versions retained per path (default 4). Oldest dropped first. */
-    maxVersionsPerPath?: number;
-    /**
-     * Global ceiling on retained snapshot text summed across every path's
-     * version history, measured in UTF-16 code units (default 64 MiB).
-     * Least-recently-used path histories are evicted to stay under it.
-     */
-    maxTotalBytes?: number;
-}
-/**
- * In-memory {@link SnapshotStore} backed by `lru-cache`. Per-path history is a
- * short ring of full-file versions (oldest dropped first); per-session path
- * tracking is LRU-bounded so cold paths age out automatically.
- *
- * Recording byte-identical content again refreshes recency and reuses the
- * existing tag (read fusion); recording new content unshifts a fresh version
- * onto the front of the path history. Two distinct texts that collide on the
- * short 4-hex tag are retained as separate versions so callers can still tell
- * them apart via {@link Snapshot.text} — the tag is only a fast index, never
- * the identity.
- */
-export declare class InMemorySnapshotStore extends SnapshotStore {
-    #private;
-    constructor(options?: InMemorySnapshotStoreOptions);
-    head(path: string): Snapshot | null;
-    byHash(path: string, hash: string): Snapshot | null;
-    byHashExact(path: string, hash: string): Snapshot | null;
-    byContent(path: string, fullText: string): Snapshot | null;
-    findByHash(hash: string): Snapshot[];
-    record(path: string, fullText: string, seenLines?: Iterable<number>): string;
-    recordSeenLines(path: string, hash: string, lines: Iterable<number>): void;
-    invalidate(path: string): void;
-    relocate(from: string, to: string): void;
-    clear(): void;
-}

package/dist/types/stream.d.ts

@@ -1,2 +0,0 @@
-import type { StreamOptions } from "./types";
-export declare function streamHashLines(source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>, options?: StreamOptions): AsyncGenerator<string>;

package/dist/types/tokenizer.d.ts

@@ -1,73 +0,0 @@
-import type { Anchor, Cursor, ParsedRange } from "./types";
-export declare function splitHashlineLines(text: string): string[];
-export declare function cloneCursor(cursor: Cursor): Cursor;
-/** Parse a bare line-number anchor. Throws on malformed input. */
-export declare function parseLid(raw: string, lineNum: number): Anchor;
-export type BlockTarget = {
-    kind: "replace";
-    range: ParsedRange;
-} | {
-    kind: "block";
-    anchor: Anchor;
-} | {
-    kind: "delete";
-    range: ParsedRange;
-} | {
-    kind: "delete_block";
-    anchor: Anchor;
-} | {
-    kind: "insert_before";
-    anchor: Anchor;
-} | {
-    kind: "insert_after";
-    anchor: Anchor;
-} | {
-    kind: "insert_after_block";
-    anchor: Anchor;
-} | {
-    kind: "rem";
-} | {
-    kind: "move";
-    dest: string;
-} | {
-    kind: "bof";
-} | {
-    kind: "eof";
-};
-interface TokenBase {
-    lineNum: number;
-}
-export type Token = (TokenBase & {
-    kind: "blank";
-}) | (TokenBase & {
-    kind: "envelope-begin";
-}) | (TokenBase & {
-    kind: "envelope-end";
-}) | (TokenBase & {
-    kind: "abort";
-}) | (TokenBase & {
-    kind: "header";
-    path: string;
-    fileHash?: string;
-}) | (TokenBase & {
-    kind: "op-block";
-    target: BlockTarget;
-}) | (TokenBase & {
-    kind: "payload-literal";
-    text: string;
-}) | (TokenBase & {
-    kind: "raw";
-    text: string;
-});
-export declare class Tokenizer {
-    #private;
-    feed(chunk: string): Token[];
-    end(): Token[];
-    reset(): void;
-    tokenizeAll(text: string): Token[];
-    tokenize(line: string, lineNum?: number): Token;
-    isOp(line: string): boolean;
-    isHeader(line: string): boolean;
-    isEnvelopeMarker(line: string): boolean;
-}
-export type { ParsedRange } from "./types";

package/dist/types/types.d.ts

@@ -1,172 +0,0 @@
-/**
- * Pure data types shared across the hashline parser, applier, and patcher.
- * Nothing in this file references a filesystem, agent runtime, or schema
- * library — keep it that way.
- */
-/** A line-number anchor (1-indexed). */
-export interface Anchor {
-    line: number;
-}
-/** Where an `insert` edit should land relative to existing content. */
-export type Cursor = {
-    kind: "bof";
-} | {
-    kind: "eof";
-} | {
-    kind: "before_anchor";
-    anchor: Anchor;
-} | {
-    kind: "after_anchor";
-    anchor: Anchor;
-};
-/**
- * A single low-level edit produced by the parser and consumed by the applier.
- * Multi-line replacements decompose to one `insert` per replacement line plus
- * one `delete` per consumed line. Replacement payloads are tagged so the
- * applier can distinguish literal insertion from new content for a deleted
- * line.
- */
-export type Edit = {
-    kind: "insert";
-    cursor: Cursor;
-    text: string;
-    lineNum: number;
-    index: number;
-    mode?: "replacement";
-    /**
-     * Present on inserts lowered from `insert_after_block N:`: the
-     * resolved block's first line. Lets the applier slide a body that
-     * claims a depth inside the block back across the block's trailing
-     * closer lines (never above this line).
-     */
-    blockStart?: number;
-} | {
-    kind: "delete";
-    anchor: Anchor;
-    lineNum: number;
-    index: number;
-    oldAssertion?: string;
-} | {
-    /**
-     * Deferred block edit (`replace_block N:` / `delete_block N` /
-     * `insert_after_block N:`). The exact line span is unknown at parse
-     * time — it is computed by {@link resolveBlockEdits} once file text +
-     * path (→ language) are available, then expanded into concrete edits:
-     * a non-empty `payloads` without `mode` (from `replace_block`) becomes
-     * the same `replacement` inserts + deletes that `replace start.=end:`
-     * produces; an empty `payloads` (from `delete_block`) becomes a pure
-     * range deletion; `mode: "insert_after"` becomes plain `after_anchor`
-     * inserts at the block's last line. `applyEdits` never sees this
-     * variant.
-     */
-    kind: "block";
-    anchor: Anchor;
-    payloads: string[];
-    mode?: "insert_after";
-    lineNum: number;
-    index: number;
-};
-/** File-level operation parsed from a section body (`REM` / `MV`). */
-export type FileOp = {
-    kind: "rem";
-} | {
-    kind: "move";
-    dest: string;
-};
-/** Result of applying a parsed set of edits to a text body. */
-export interface ApplyResult {
-    /** Post-edit text body. */
-    text: string;
-    /** First line number (1-indexed) that changed, or `undefined` for a no-op apply. */
-    firstChangedLine?: number;
-    /** Diagnostic warnings collected by the parser, patcher, or recovery. */
-    warnings?: string[];
-    /**
-     * Resolved spans for each `replace_block`/`delete_block` op in this apply,
-     * in patch order. Present only when the apply matched the tagged content
-     * (the common no-drift path), so the line numbers line up with what the
-     * caller read. Absent when there were no block ops.
-     */
-    blockResolutions?: BlockResolution[];
-}
-/** A parsed `[A.=B]` line range. */
-export interface ParsedRange {
-    start: Anchor;
-    end: Anchor;
-}
-/** Optional hints for {@link splitPatchInput}. */
-export interface SplitOptions {
-    /** Resolves absolute paths inside hashline headers to cwd-relative form. */
-    cwd?: string;
-    /**
-     * Fallback path used when the input lacks a `[PATH]` header but contains
-     * recognizable hashline operations. Lets streaming previews work before
-     * the model has written the header.
-     */
-    path?: string;
-}
-/** Streaming-formatter knobs for {@link streamHashLines}. */
-export interface StreamOptions {
-    /** First line number to use when formatting (1-indexed, default 1). */
-    startLine?: number;
-    /** Maximum formatted lines per yielded chunk (default 200). */
-    maxChunkLines?: number;
-    /** Maximum UTF-8 bytes per yielded chunk (default 64 KiB). */
-    maxChunkBytes?: number;
-}
-/** Result of {@link buildCompactDiffPreview}. */
-export interface CompactDiffPreview {
-    preview: string;
-    addedLines: number;
-    removedLines: number;
-}
-/** Optional knobs for {@link buildCompactDiffPreview}. */
-export interface CompactDiffOptions {
-    /** Added lines kept on each side of a long added-run elision (default 2). */
-    maxAddedRunContext?: number;
-    /** Back-compat alias for {@link maxAddedRunContext}. */
-    maxUnchangedRun?: number;
-}
-/**
- * Resolved 1-indexed inclusive line span of a `replace_block N:` target.
- */
-export interface BlockSpan {
-    /** First line of the block (1-indexed, inclusive). */
-    start: number;
-    /** Last line of the block (1-indexed, inclusive). */
-    end: number;
-}
-/**
- * One `replace_block N:` / `delete_block N` / `insert_after_block N:` anchor
- * resolved to its concrete line span. Surfaced on {@link ApplyResult} so the
- * host can echo "block N → lines start.=end" and let the model catch a wrong
- * opener — e.g. a decorator or doc-comment that sits in a separate node
- * outside the resolved block.
- */
-export interface BlockResolution {
-    /** The 1-indexed line the block op was anchored on (the `N`). */
-    anchorLine: number;
-    /** First line of the resolved span (1-indexed, inclusive). */
-    start: number;
-    /** Last line of the resolved span (1-indexed, inclusive). */
-    end: number;
-    /** Which block op produced this resolution. */
-    op: "replace" | "delete" | "insert_after";
-}
-/** Request handed to a {@link BlockResolver} to resolve one `replace_block N:` anchor. */
-export interface BlockResolverRequest {
-    /** Target file path (used to infer language by extension). */
-    path: string;
-    /** Full text the block must be resolved against (the snapshot the tag names). */
-    text: string;
-    /** 1-indexed line the block must begin on. */
-    line: number;
-}
-/**
- * Resolves a `replace_block N:` anchor to the line span of the syntactic block
- * that begins on line N. Returns `null` when no block can be resolved
- * (unrecognized language, blank/out-of-range line, no node begins there, or the
- * resolved subtree has a syntax error). Pure seam: the hashline core declares
- * the contract; the host injects a tree-sitter-backed implementation.
- */
-export type BlockResolver = (request: BlockResolverRequest) => BlockSpan | null;