blockpatch 0.1.0 → 1.1.0

package/dist/cli.js

@@ -1,265 +1,2612 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve2 } from "node:path";
+import { createRequire } from "node:module";
+import { resolve as resolve3 } from "node:path";
 
 // src/errors.ts
+var maxErrorRanges = 10;
+
 class BlockPatchError extends Error {
   code;
-  constructor(code, message) {
+  details;
+  constructor(code, message, details = {}) {
     super(message);
     this.name = "BlockPatchError";
     this.code = code;
+    this.details = details;
+  }
+}
+function fail(code, message, details) {
+  throw new BlockPatchError(code, message, details);
+}
+function matchedLocations(count, truncated) {
+  return `matched ${truncated ? "at least " : ""}${count} locations`;
+}
+function matchCountDetails(count, truncated) {
+  return truncated ? { matches: count, matches_truncated: true } : { matches: count };
+}
+function boundedMatchRanges(matches, byteLength) {
+  const ranges = [];
+  for (const start of matches) {
+    if (ranges.length >= maxErrorRanges) {
+      break;
+    }
+    ranges.push({ start, end: start + byteLength });
+  }
+  return ranges;
+}
+function boundedRanges(matches) {
+  const ranges = [];
+  for (const range of matches) {
+    if (ranges.length >= maxErrorRanges) {
+      break;
+    }
+    ranges.push({ start: range.start, end: range.end });
+  }
+  return ranges;
+}
+function boundedMatchLineRanges(file, matches, byteLength) {
+  const lineRanges = [];
+  for (const start of matches) {
+    if (lineRanges.length >= maxErrorRanges) {
+      break;
+    }
+    lineRanges.push(byteRangeToLineRange(file, { start, end: start + byteLength }));
+  }
+  return lineRanges;
+}
+function boundedLineRanges(file, ranges) {
+  return boundedRanges(ranges).map((range) => byteRangeToLineRange(file, range));
+}
+function byteRangeToLineRange(file, range) {
+  const start = clamp(range.start, 0, file.length);
+  const end = clamp(range.end, start, file.length);
+  const endByte = end > start ? end - 1 : start;
+  return {
+    start: lineNumberAt(file, start),
+    end: lineNumberAt(file, endByte)
+  };
+}
+function lineNumberAt(file, byteIndex) {
+  let line = 1;
+  const end = Math.min(byteIndex, file.length);
+  for (let index = 0;index < end; index += 1) {
+    if (file[index] === 10) {
+      line += 1;
+    }
+  }
+  return line;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/engine.ts
+import { Buffer as Buffer3 } from "node:buffer";
+import { randomBytes } from "node:crypto";
+import { chmod, lstat, mkdir, rename, rmdir, stat as stat2, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+
+// src/files.ts
+import { createHash } from "node:crypto";
+import { lstatSync, realpathSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+async function readFileChecked(path, label) {
+  try {
+    return await readFile(path);
+  } catch (error) {
+    failFileSystem(error, path, `Could not read ${label}`);
+  }
+}
+async function readFileSnapshot(path, label) {
+  const bytes = await readFileChecked(path, label);
+  const info = await statChecked(path, label);
+  assertRegularFile(info, path, label);
+  return fileSnapshot(bytes, info);
+}
+function fileSnapshot(bytes, info) {
+  return {
+    bytes,
+    sha256: hashBytes(bytes),
+    stat: statSnapshot(info)
+  };
+}
+function hashBytes(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+async function statChecked(path, label) {
+  try {
+    return await stat(path);
+  } catch (error) {
+    failFileSystem(error, path, `Could not stat ${label}`);
+  }
+}
+function lstatSyncChecked(path, label, userPath = path) {
+  try {
+    return lstatSync(path);
+  } catch (error) {
+    failFileSystem(error, userPath, `Could not stat ${label}`, "path");
+  }
+}
+function realpathSyncChecked(path, label, userPath = path) {
+  try {
+    return realpathSync(path);
+  } catch (error) {
+    failFileSystem(error, userPath, `Could not resolve ${label}`, "path");
+  }
+}
+function assertRegularFile(info, path, label, phase = "io") {
+  if (!info.isFile()) {
+    fail("not_regular_file", `${label} must be a regular file: ${path}`, { path, phase });
+  }
+}
+function failFileSystem(error, path, action, phase = "io") {
+  if (error instanceof BlockPatchError) {
+    throw error;
+  }
+  const message = error instanceof Error ? `${action}: ${error.message}` : `${action}: ${path}`;
+  fail(fileSystemErrorCode(error), message, { path, phase });
+}
+function statSnapshot(info) {
+  return {
+    dev: info.dev,
+    ino: info.ino,
+    mode: info.mode,
+    size: info.size,
+    mtimeMs: info.mtimeMs,
+    ctimeMs: info.ctimeMs
+  };
+}
+function fileSystemErrorCode(error) {
+  switch (error.code) {
+    case "ENOENT":
+    case "ENOTDIR":
+      return "file_not_found";
+    case "EISDIR":
+      return "not_regular_file";
+    case "EACCES":
+    case "EPERM":
+      return "permission_denied";
+    default:
+      return "io_error";
+  }
+}
+
+// src/parser.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { createHash as createHash2 } from "node:crypto";
+import { posix } from "node:path";
+
+// src/paths.ts
+import { lstatSync as lstatSync2 } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
+function validateOperationPath(path, label) {
+  if (path === "") {
+    fail("invalid_path", `Invalid ${label}: ${path}`, { path, phase: "path" });
+  }
+  rejectUnsafeDisplayPath(path, label);
+  rejectAbsolutePath(path, label);
+  rejectBackslashPath(path, label);
+}
+function rejectUnsafeDisplayPath(path, label) {
+  if (/[\x00-\x1f\x7f-\x9f]/u.test(path)) {
+    fail("invalid_path", `${label} contains unsupported control characters`, {
+      path,
+      phase: "path"
+    });
+  }
+}
+function rejectBackslashPath(path, label) {
+  if (path.includes("\\")) {
+    fail("invalid_path", `${label} must use POSIX-style / separators: ${path}`, {
+      path,
+      phase: "path"
+    });
+  }
+}
+function rejectAbsolutePath(path, label) {
+  if (isAbsolute(path) || win32.isAbsolute(path)) {
+    fail("path_outside_cwd", `${label} must be relative to the working directory: ${path}`, {
+      path,
+      phase: "path"
+    });
+  }
+}
+function rejectDotPathSegments(path, label) {
+  if (path.split("/").some((part) => part === "." || part === "..")) {
+    fail("invalid_path", `${label} must not contain . or .. path segments: ${path}`, {
+      path,
+      phase: "path"
+    });
+  }
+}
+function resolvePath(cwd, path, label) {
+  validateOperationPath(path, label);
+  const root = resolve(cwd);
+  const resolved = resolve(root, path);
+  const realRoot = realpathSyncChecked(root, "working directory", root);
+  if (!isInside(root, resolved)) {
+    fail("path_outside_cwd", `${label} escapes the working directory: ${path}`, { path, phase: "path" });
+  }
+  rejectDotPathSegments(path, label);
+  rejectSymlinkComponents(root, resolved, path, label);
+  const info = lstatSyncChecked(resolved, label, path);
+  assertRegularFile(info, path, label, "path");
+  const realResolved = realpathSyncChecked(resolved, label, path);
+  if (!isInside(realRoot, realResolved)) {
+    fail("path_outside_cwd", `${label} resolves outside the working directory: ${path}`, { path, phase: "path" });
+  }
+  return resolved;
+}
+function resolvePathAllowMissing(cwd, path, label) {
+  validateOperationPath(path, label);
+  const root = resolve(cwd);
+  const resolved = resolve(root, path);
+  const realRoot = realpathSyncChecked(root, "working directory", root);
+  if (!isInside(root, resolved)) {
+    fail("path_outside_cwd", `${label} escapes the working directory: ${path}`, { path, phase: "path" });
+  }
+  rejectDotPathSegments(path, label);
+  const deepestExisting = rejectExistingSymlinkComponents(root, resolved, path, label);
+  if (deepestExisting !== resolved) {
+    return { path: resolved, exists: false };
+  }
+  const info = lstatSyncChecked(resolved, label, path);
+  assertRegularFile(info, path, label, "path");
+  const realResolved = realpathSyncChecked(resolved, label, path);
+  if (!isInside(realRoot, realResolved)) {
+    fail("path_outside_cwd", `${label} resolves outside the working directory: ${path}`, { path, phase: "path" });
+  }
+  return { path: resolved, exists: true };
+}
+async function sameFileIdentity(left, right) {
+  if (left === right) {
+    return true;
+  }
+  const [leftInfo, rightInfo] = await Promise.all([
+    statChecked(left, "source path"),
+    statChecked(right, "destination path")
+  ]);
+  return leftInfo.dev === rightInfo.dev && leftInfo.ino === rightInfo.ino;
+}
+function rejectSymlinkComponents(root, resolved, originalPath, label) {
+  const relativePath = relative(root, resolved);
+  if (relativePath === "") {
+    return;
+  }
+  let current = root;
+  for (const part of relativePath.split(sep)) {
+    current = join(current, part);
+    if (lstatSyncChecked(current, label, originalPath).isSymbolicLink()) {
+      fail("symlink_path", `${label} must not contain symbolic links: ${originalPath}`, {
+        path: originalPath,
+        phase: "path"
+      });
+    }
+  }
+}
+function rejectExistingSymlinkComponents(root, resolved, originalPath, label) {
+  const relativePath = relative(root, resolved);
+  if (relativePath === "") {
+    return resolved;
+  }
+  let current = root;
+  for (const part of relativePath.split(sep)) {
+    const next = join(current, part);
+    let info;
+    try {
+      info = lstatSync2(next);
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        return current;
+      }
+      failFileSystem(error, originalPath, `Could not stat ${label}`, "path");
+    }
+    if (info.isSymbolicLink()) {
+      fail("symlink_path", `${label} must not contain symbolic links: ${originalPath}`, {
+        path: originalPath,
+        phase: "path"
+      });
+    }
+    current = next;
+  }
+  return current;
+}
+function isInside(root, path) {
+  const fromRoot = relative(root, path);
+  return fromRoot === "" || !fromRoot.startsWith("..") && !isAbsolute(fromRoot);
+}
+
+// src/parser.ts
+var devNull = "/dev/null";
+var noNewlineMarker = "\";
+var movePrefix = "blockpatch move ";
+var allowedMetadataKeys = new Set(["id", "payload-sha256", "role"]);
+var hunkPattern = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@ blockpatch-(source|target) id=([^\s]+)(?: .*)?$/;
+function parseBlockPatch(input, options = {}) {
+  const lines = splitLines(input);
+  const sections = parseSections(lines, normalizeStripComponents(options.stripComponents ?? 1));
+  if (sections.length === 1) {
+    return parseSingleSectionMove(sections[0]);
+  }
+  if (sections.length === 2) {
+    return parseSplitSectionMove(sections);
+  }
+  fail("parse_error", "Patch must contain one same-file move or one split cross-file move");
+}
+function parseSingleSectionMove(section) {
+  if (section.src === null && section.dst === null) {
+    fail("parse_error", "Patch cannot use /dev/null for both endpoints");
+  }
+  if (section.role !== undefined) {
+    if (section.role === "source" && section.dst !== null) {
+      fail("parse_error", "A source role section without a target role section must target /dev/null");
+    }
+    if (section.role === "target" && section.src !== null) {
+      fail("parse_error", "A target role section without a source role section must source /dev/null");
+    }
+  }
+  if (section.src !== null && section.dst !== null && !samePatchPath(section.src, section.dst)) {
+    fail("parse_error", "Cross-file moves must use separate source and target file sections");
+  }
+  if (section.hunks.length < 1 || section.hunks.length > 2) {
+    fail("parse_error", "Patch must contain one or two blockpatch hunks");
+  }
+  const sourceHunks = section.hunks.filter((hunk) => hunk.kind === "source");
+  const targetHunks = section.hunks.filter((hunk) => hunk.kind === "target");
+  if (sourceHunks.length > 1 || targetHunks.length > 1) {
+    fail("parse_error", "Patch must contain at most one source hunk and at most one target hunk");
+  }
+  const sourceHunk = sourceHunks[0];
+  const targetHunk = targetHunks[0];
+  for (const hunk of section.hunks) {
+    if (hunk.id !== section.moveId) {
+      fail("parse_error", "Move metadata id must match source and target hunk ids");
+    }
+  }
+  if (section.src === null) {
+    if (sourceHunk !== undefined || targetHunk === undefined) {
+      fail("parse_error", "A move from /dev/null must contain exactly one blockpatch-target hunk");
+    }
+    return buildTargetOnlyBlockPatch(section, targetHunk, { pathState: true });
+  }
+  if (section.dst === null) {
+    if (sourceHunk === undefined || targetHunk !== undefined) {
+      fail("parse_error", "A move to /dev/null must contain exactly one blockpatch-source hunk");
+    }
+    return buildSourceOnlyBlockPatch(section, sourceHunk, { pathState: true });
+  }
+  if (sourceHunk !== undefined && targetHunk !== undefined) {
+    return buildPairedBlockPatch(section.src, section.dst, section.moveId, section.payloadSha256, sourceHunk, targetHunk);
+  }
+  if (sourceHunk !== undefined) {
+    return buildSourceOnlyBlockPatch(section, sourceHunk, { pathState: false });
+  }
+  if (targetHunk !== undefined) {
+    return buildTargetOnlyBlockPatch(section, targetHunk, { pathState: false });
+  }
+  fail("parse_error", "Patch must contain at least one blockpatch hunk");
+}
+function parseSplitSectionMove(sections) {
+  if (sections.some((section) => section.src === null || section.dst === null)) {
+    fail("parse_error", "/dev/null endpoints are only valid in single-section moves");
+  }
+  if (sections.some((section) => section.role === undefined)) {
+    fail("parse_error", "Split cross-file move sections must include role=source or role=target");
+  }
+  const sourceSections = sections.filter((section) => section.role === "source");
+  const targetSections = sections.filter((section) => section.role === "target");
+  if (sourceSections.length !== 1 || targetSections.length !== 1) {
+    fail("parse_error", "Split cross-file moves must contain one source role section and one target role section");
+  }
+  const sourceSection = sourceSections[0];
+  const targetSection = targetSections[0];
+  const sourceFile = sourceSection.src;
+  const targetFile = targetSection.src;
+  if (!samePatchPath(sourceFile, sourceSection.dst) || !samePatchPath(targetFile, targetSection.dst)) {
+    fail("parse_error", "Split cross-file section headers must name the same file in --- and +++");
+  }
+  if (samePatchPath(sourceFile, targetFile)) {
+    fail("parse_error", "Split cross-file moves require different source and target files");
+  }
+  if (sourceSection.moveId !== targetSection.moveId) {
+    fail("parse_error", "Split cross-file move sections must use the same move id");
+  }
+  if (sourceSection.payloadSha256 !== targetSection.payloadSha256) {
+    fail("parse_error", "Split cross-file move sections must use the same payload-sha256");
+  }
+  if (sourceSection.hunks.length !== 1 || sourceSection.hunks[0].kind !== "source") {
+    fail("parse_error", "Source role section must contain exactly one blockpatch-source hunk");
+  }
+  if (targetSection.hunks.length !== 1 || targetSection.hunks[0].kind !== "target") {
+    fail("parse_error", "Target role section must contain exactly one blockpatch-target hunk");
+  }
+  const sourceHunk = sourceSection.hunks[0];
+  const targetHunk = targetSection.hunks[0];
+  if (sourceHunk.id !== sourceSection.moveId || targetHunk.id !== targetSection.moveId) {
+    fail("parse_error", "Move metadata id must match source and target hunk ids");
+  }
+  return buildPairedBlockPatch(sourceFile, targetFile, sourceSection.moveId, sourceSection.payloadSha256, sourceHunk, targetHunk);
+}
+function buildPairedBlockPatch(src, dst, moveId, payloadSha256, sourceHunk, targetHunk) {
+  const source = parseSourceHunk(sourceHunk);
+  const target = parseTargetHunk(targetHunk);
+  const targetPayload = payloadBytes(targetHunk, "+");
+  if (!source.payload.equals(targetPayload)) {
+    fail("payload_mismatch", "Target added payload does not match source removed payload", {
+      phase: "payload",
+      anchor: "blockpatch-target"
+    });
+  }
+  verifyPayloadHash(source.payload, payloadSha256);
+  return {
+    type: "move",
+    id: moveId,
+    src,
+    dst,
+    payloadSha256,
+    hasSourceHunk: true,
+    sourceBefore: source.before,
+    sourcePayload: source.payload,
+    sourceAfter: source.after,
+    target
+  };
+}
+function buildSourceOnlyBlockPatch(section, sourceHunk, options) {
+  const source = parseSourceHunk(sourceHunk, { allowEmptyPayload: options.pathState });
+  if (options.pathState && (source.before.length !== 0 || source.after.length !== 0)) {
+    fail("parse_error", "A move to /dev/null must describe whole-file payload without context");
+  }
+  verifyPayloadHash(source.payload, section.payloadSha256);
+  return {
+    type: "move",
+    id: section.moveId,
+    src: section.src,
+    dst: section.dst,
+    payloadSha256: section.payloadSha256,
+    hasSourceHunk: true,
+    sourceBefore: source.before,
+    sourcePayload: source.payload,
+    sourceAfter: source.after,
+    target: null
+  };
+}
+function buildTargetOnlyBlockPatch(section, targetHunk, options) {
+  const target = parseTargetHunk(targetHunk, {
+    allowEmptyAnchors: options.pathState,
+    allowEmptyPayload: options.pathState
+  });
+  if (options.pathState && (target.before.length !== 0 || target.after.length !== 0)) {
+    fail("parse_error", "A move from /dev/null must describe whole-file payload without context");
+  }
+  const payload = payloadBytes(targetHunk, "+");
+  verifyPayloadHash(payload, section.payloadSha256);
+  return {
+    type: "move",
+    id: section.moveId,
+    src: section.src,
+    dst: section.dst,
+    payloadSha256: section.payloadSha256,
+    hasSourceHunk: false,
+    sourceBefore: Buffer2.alloc(0),
+    sourcePayload: payload,
+    sourceAfter: Buffer2.alloc(0),
+    target
+  };
+}
+function verifyPayloadHash(payload, payloadSha256) {
+  const actualHash = createHash2("sha256").update(payload).digest("hex");
+  if (actualHash !== payloadSha256) {
+    fail("hash_mismatch", "payload-sha256 does not match moved payload", {
+      phase: "payload",
+      anchor: "payload-sha256"
+    });
+  }
+}
+function parseSections(lines, stripComponents) {
+  if (text(lines[0])?.startsWith("diff --blockpatch ") !== true) {
+    fail("parse_error", "Patch must start with diff --blockpatch");
+  }
+  const starts = [];
+  for (let index = 0;index < lines.length; index += 1) {
+    if (text(lines[index])?.startsWith("diff --blockpatch ") === true) {
+      starts.push(index);
+    }
+  }
+  return starts.map((start, index) => {
+    const end = starts[index + 1] ?? lines.length;
+    return parseSection(lines, start, end, stripComponents);
+  });
+}
+function parseSection(lines, start, end, stripComponents) {
+  if (text(lines[start + 1]) !== "blockpatch version 1") {
+    fail("parse_error", "Patch must declare blockpatch version 1");
+  }
+  const moveLine = text(lines[start + 2]);
+  if (moveLine?.startsWith(movePrefix) !== true) {
+    fail("parse_error", "Patch must declare blockpatch move metadata");
+  }
+  const metadata = parseMetadata(moveLine.slice(movePrefix.length));
+  const moveId = metadata.get("id");
+  const payloadSha256 = metadata.get("payload-sha256");
+  const role = metadata.get("role");
+  if (!moveId) {
+    fail("parse_error", "blockpatch move metadata must include id=<id>");
+  }
+  if (!payloadSha256 || !/^[a-f0-9]{64}$/.test(payloadSha256)) {
+    fail("parse_error", "blockpatch move metadata must include payload-sha256=<64 hex chars>");
+  }
+  if (role !== undefined && role !== "source" && role !== "target") {
+    fail("parse_error", "blockpatch move role must be source or target");
+  }
+  const oldRawPath = parseFileHeader(text(lines[start + 3]), "---", "a/");
+  const newRawPath = parseFileHeader(text(lines[start + 4]), "+++", "b/");
+  if (text(lines[start])?.trimEnd() !== `diff --blockpatch ${oldRawPath} ${newRawPath}`) {
+    fail("parse_error", "diff --blockpatch paths must match the --- and +++ headers");
+  }
+  let hunkStart = start + 5;
+  while (hunkStart < end && text(lines[hunkStart]) === "") {
+    hunkStart += 1;
+  }
+  return {
+    src: oldRawPath === devNull ? null : stripPath(oldRawPath, stripComponents),
+    dst: newRawPath === devNull ? null : stripPath(newRawPath, stripComponents),
+    moveId,
+    payloadSha256,
+    role,
+    hunks: parseHunks(lines, hunkStart, end)
+  };
+}
+function normalizeStripComponents(value) {
+  if (!Number.isInteger(value) || value < 0) {
+    fail("parse_error", "stripComponents must be a non-negative integer");
+  }
+  return value;
+}
+function parseHunks(lines, start, end) {
+  const hunks = [];
+  let index = start;
+  while (index < end) {
+    const header = text(lines[index]);
+    if (header === "") {
+      index += 1;
+      continue;
+    }
+    const parsedHeader = parseHunkHeader(header);
+    if (parsedHeader === undefined) {
+      fail("parse_error", "Expected blockpatch source/target hunk header");
+    }
+    const hunk = {
+      kind: parsedHeader.kind,
+      id: parsedHeader.id,
+      oldCount: parsedHeader.oldCount,
+      newCount: parsedHeader.newCount,
+      lines: []
+    };
+    index += 1;
+    while (index < end) {
+      const maybeHeader = text(lines[index]);
+      if (parseHunkHeader(maybeHeader) !== undefined) {
+        break;
+      }
+      const body = lines[index].body;
+      if (body.length === 0) {
+        let lookahead = index + 1;
+        while (lookahead < end && lines[lookahead].body.length === 0) {
+          lookahead += 1;
+        }
+        if (lookahead < end && parseHunkHeader(text(lines[lookahead])) === undefined) {
+          fail("parse_error", "Hunk bodies must not contain blank lines; encode an empty context line as a single space");
+        }
+        break;
+      }
+      const first = body[0];
+      if (first !== 32 && first !== 45 && first !== 43) {
+        fail("parse_error", "Hunk body lines must start with space, -, or +");
+      }
+      let content = Buffer2.concat([body.subarray(1), lines[index].eol]);
+      if (index + 1 < lines.length && text(lines[index + 1]) === noNewlineMarker) {
+        const bareCr = lines[index].eol[0] === 13 ? lines[index].eol.subarray(0, 1) : Buffer2.alloc(0);
+        content = Buffer2.concat([body.subarray(1), bareCr]);
+        index += 1;
+      }
+      hunk.lines.push({
+        prefix: String.fromCharCode(first),
+        content
+      });
+      index += 1;
+    }
+    validateHunkCounts(hunk);
+    hunks.push(hunk);
+  }
+  return hunks;
+}
+function samePatchPath(left, right) {
+  return posix.normalize(left) === posix.normalize(right);
+}
+function parseHunkHeader(header) {
+  const match = header?.match(hunkPattern);
+  if (match === undefined || match === null) {
+    return;
+  }
+  return {
+    oldCount: match[1] === undefined ? 1 : Number(match[1]),
+    newCount: match[2] === undefined ? 1 : Number(match[2]),
+    kind: match[3] === "source" ? "source" : "target",
+    id: match[4]
+  };
+}
+function validateHunkCounts(hunk) {
+  const oldCount = hunk.lines.filter((line) => line.prefix === " " || line.prefix === "-").length;
+  const newCount = hunk.lines.filter((line) => line.prefix === " " || line.prefix === "+").length;
+  if (oldCount !== hunk.oldCount || newCount !== hunk.newCount) {
+    fail("parse_error", `Hunk line counts do not match header for blockpatch-${hunk.kind} id=${hunk.id}`);
+  }
+}
+function parseSourceHunk(hunk, options = {}) {
+  const removedIndexes = hunk.lines.map((line, index) => line.prefix === "-" ? index : -1).filter((index) => index !== -1);
+  if (removedIndexes.length === 0) {
+    if (options.allowEmptyPayload === true && hunk.lines.length === 0) {
+      return { before: Buffer2.alloc(0), payload: Buffer2.alloc(0), after: Buffer2.alloc(0) };
+    }
+    fail("parse_error", "Source hunk must contain removed payload lines");
+  }
+  assertContiguous(removedIndexes, "Source payload lines must be contiguous");
+  const firstRemoved = removedIndexes[0];
+  const lastRemoved = removedIndexes[removedIndexes.length - 1];
+  const beforeLines = hunk.lines.slice(0, firstRemoved);
+  const afterLines = hunk.lines.slice(lastRemoved + 1);
+  if (!beforeLines.every((line) => line.prefix === " ") || !afterLines.every((line) => line.prefix === " ")) {
+    fail("parse_error", "Source hunk may only contain context lines around removed payload");
+  }
+  const before = concatLines(beforeLines);
+  const payload = payloadBytes(hunk, "-");
+  const after = concatLines(afterLines);
+  return { before, payload, after };
+}
+function parseTargetHunk(hunk, options = {}) {
+  const addedIndexes = hunk.lines.map((line, index) => line.prefix === "+" ? index : -1).filter((index) => index !== -1);
+  if (addedIndexes.length === 0) {
+    if (options.allowEmptyPayload === true && hunk.lines.length === 0) {
+      return { before: Buffer2.alloc(0), after: Buffer2.alloc(0) };
+    }
+    fail("parse_error", "Target hunk must contain added payload lines");
+  }
+  assertContiguous(addedIndexes, "Target payload lines must be contiguous");
+  const firstAdded = addedIndexes[0];
+  const lastAdded = addedIndexes[addedIndexes.length - 1];
+  const beforeLines = hunk.lines.slice(0, firstAdded);
+  const afterLines = hunk.lines.slice(lastAdded + 1);
+  if (!beforeLines.every((line) => line.prefix === " ") || !afterLines.every((line) => line.prefix === " ")) {
+    fail("parse_error", "Target hunk may only contain context lines around added payload");
+  }
+  const before = concatLines(beforeLines);
+  const after = concatLines(afterLines);
+  if (before.length === 0 && after.length === 0 && options.allowEmptyAnchors !== true) {
+    fail("parse_error", "Target hunk must include context before or after the moved payload");
+  }
+  return { before, after };
+}
+function payloadBytes(hunk, prefix) {
+  return concatLines(hunk.lines.filter((line) => line.prefix === prefix));
+}
+function concatLines(lines) {
+  return Buffer2.concat(lines.map((line) => line.content));
+}
+function assertContiguous(indexes, message) {
+  for (let index = 1;index < indexes.length; index += 1) {
+    if (indexes[index] !== indexes[index - 1] + 1) {
+      fail("parse_error", message);
+    }
+  }
+}
+function parseMetadata(input) {
+  const metadata = new Map;
+  for (const part of input.trim().split(/\s+/)) {
+    const equals = part.indexOf("=");
+    if (equals <= 0) {
+      fail("parse_error", `Invalid blockpatch move metadata field: ${part}`);
+    }
+    const key = part.slice(0, equals);
+    if (metadata.has(key)) {
+      fail("parse_error", `Duplicate blockpatch move metadata field: ${key}`);
+    }
+    if (!allowedMetadataKeys.has(key) && !key.startsWith("x-")) {
+      fail("parse_error", `Unknown blockpatch move metadata field: ${key}`);
+    }
+    metadata.set(key, part.slice(equals + 1));
+  }
+  return metadata;
+}
+function parseFileHeader(line, prefix, requiredPathPrefix) {
+  const marker = `${prefix} `;
+  const rawPath = line?.startsWith(marker) === true ? line.slice(marker.length) : undefined;
+  if (rawPath !== undefined) {
+    rejectUnsafeDisplayPath(rawPath, `${prefix} file header path`);
+  }
+  if (rawPath?.trim() === devNull && line?.startsWith(marker)) {
+    return devNull;
+  }
+  if (line?.startsWith(`${marker}${requiredPathPrefix}`) !== true) {
+    fail("parse_error", `Patch must include a ${marker}${requiredPathPrefix}<path> or ${marker}${devNull} header`);
+  }
+  const path = rawPath?.trim() ?? "";
+  if (!path || path === requiredPathPrefix) {
+    fail("parse_error", `${prefix} file header must include a path`);
+  }
+  return path;
+}
+function stripPath(path, stripComponents) {
+  const stripped = path.split("/").slice(stripComponents).join("/");
+  if (!stripped) {
+    fail("parse_error", `-p${stripComponents} removes the entire path: ${path}`);
+  }
+  return stripped;
+}
+function splitLines(input) {
+  const lines = [];
+  let position = 0;
+  while (position < input.length) {
+    const lf = input.indexOf(10, position);
+    const lineEnd = lf === -1 ? input.length : lf;
+    const hasCr = lf !== -1 && lineEnd > position && input[lineEnd - 1] === 13;
+    const bodyEnd = hasCr ? lineEnd - 1 : lineEnd;
+    const eol = lf === -1 ? Buffer2.alloc(0) : input.subarray(hasCr ? lineEnd - 1 : lineEnd, lf + 1);
+    lines.push({
+      body: Buffer2.from(input.subarray(position, bodyEnd)),
+      eol: Buffer2.from(eol)
+    });
+    if (lf === -1) {
+      break;
+    }
+    position = lf + 1;
+  }
+  return lines;
+}
+function text(line) {
+  return line?.body.toString("utf8");
+}
+
+// src/engine.ts
+async function checkPatchFile(patchPath, options = {}) {
+  return runPatchFile(patchPath, { ...options, dryRun: true });
+}
+async function checkPatchBytes(patchBytes, options = {}) {
+  return runPatchBytes(patchBytes, { ...options, dryRun: true });
+}
+function checkPatchBytesInMemory(patchBytes, files, options = {}) {
+  const patch = parseBlockPatch(patchBytes, { stripComponents: options.stripComponents });
+  const effectivePatch = options.reverse === true ? reverseMovePatch(patch) : patch;
+  return planMovePatch(effectivePatch, memoryFileMap(files)).result;
+}
+async function applyPatchFile(patchPath, options = {}) {
+  return runPatchFile(patchPath, options);
+}
+async function applyPatchBytes(patchBytes, options = {}) {
+  return runPatchBytes(patchBytes, options);
+}
+async function runPatchFile(patchPath, options) {
+  const cwd = resolve2(options.cwd ?? process.cwd());
+  const patchBytes = await readFileChecked(resolve2(cwd, patchPath), "patch file");
+  return runPatchBytes(patchBytes, { ...options, cwd });
+}
+async function runPatchBytes(patchBytes, options) {
+  const cwd = resolve2(options.cwd ?? process.cwd());
+  const patch = parseBlockPatch(patchBytes, { stripComponents: options.stripComponents });
+  return applyMovePatch(patch, cwd, options.dryRun ?? false, options.reverse ?? false);
+}
+async function applyMovePatch(patch, cwd, dryRun, reverse) {
+  const effectivePatch = reverse ? reverseMovePatch(patch) : patch;
+  const workspace = await readPatchWorkspace(effectivePatch, cwd);
+  const plan = planMovePatch(effectivePatch, workspace.files);
+  if (!dryRun) {
+    await commitPatchMutations(plan.mutations, workspace.paths);
+  }
+  return resultWithWriteFlag(plan.result, dryRun);
+}
+async function readPatchWorkspace(patch, cwd) {
+  const workspace = {
+    files: new Map,
+    paths: new Map
+  };
+  if (patch.src === null || patch.dst === null) {
+    if (patch.src === null && patch.dst !== null && !patch.hasSourceHunk) {
+      const resolved = resolvePathAllowMissing(cwd, patch.dst, "destination path");
+      if (resolved.exists) {
+        rememberFile(workspace, patch.dst, resolved.path, await readFileSnapshot(resolved.path, "destination file"));
+      } else {
+        rememberMissingPath(workspace, patch.dst, resolved.path);
+      }
+      return workspace;
+    }
+    if (patch.dst === null && patch.src !== null && patch.hasSourceHunk) {
+      const resolved = resolvePathAllowMissing(cwd, patch.src, "source path");
+      if (resolved.exists) {
+        rememberFile(workspace, patch.src, resolved.path, await readFileSnapshot(resolved.path, "source file"));
+      } else {
+        rememberMissingPath(workspace, patch.src, resolved.path);
+      }
+      return workspace;
+    }
+    fail("parse_error", "Invalid /dev/null endpoint move shape");
+  }
+  if (!patch.hasSourceHunk) {
+    const dstPath2 = resolvePath(cwd, patch.dst, "destination path");
+    rememberFile(workspace, patch.dst, dstPath2, await readFileSnapshot(dstPath2, "destination file"));
+    return workspace;
+  }
+  if (patch.target === null) {
+    const srcPath2 = resolvePath(cwd, patch.src, "source path");
+    rememberFile(workspace, patch.src, srcPath2, await readFileSnapshot(srcPath2, "source file"));
+    return workspace;
+  }
+  const srcPath = resolvePath(cwd, patch.src, "source path");
+  const dstPath = resolvePath(cwd, patch.dst, "destination path");
+  const sameFile = await sameFileIdentity(srcPath, dstPath);
+  const srcSnapshot = await readFileSnapshot(srcPath, "source file");
+  const dstSnapshot = sameFile ? srcSnapshot : await readFileSnapshot(dstPath, "destination file");
+  const identity = sameFile ? "paired-file" : undefined;
+  rememberFile(workspace, patch.src, srcPath, srcSnapshot, identity);
+  rememberFile(workspace, patch.dst, dstPath, dstSnapshot, identity);
+  return workspace;
+}
+function rememberMissingPath(workspace, label, path) {
+  workspace.paths.set(label, { path, missing: true });
+}
+function rememberFile(workspace, label, path, snapshot, identity = path) {
+  workspace.paths.set(label, { path, snapshot });
+  workspace.files.set(label, { bytes: snapshot.bytes, identity });
+}
+async function commitPatchMutations(mutations, paths) {
+  const writes = [];
+  const deletes = [];
+  for (const mutation of mutations) {
+    const pathState = mutationPath(paths, mutation.label);
+    if (mutation.kind === "write") {
+      writes.push({
+        path: pathState.path,
+        bytes: mutation.bytes,
+        create: mutation.create,
+        label: mutation.label,
+        expected: writeExpectation(mutation, pathState)
+      });
+    } else {
+      deletes.push({
+        path: pathState.path,
+        label: mutation.label,
+        expected: fileExpectation(mutation.label, pathState)
+      });
+    }
+  }
+  await writeAtomically(writes, deletes);
+}
+function writeExpectation(mutation, state) {
+  if (state.snapshot !== undefined) {
+    return { kind: "file", label: mutation.label, snapshot: state.snapshot };
+  }
+  if (state.missing === true && mutation.create === true) {
+    return { kind: "missing", label: mutation.label, bytesIfExists: mutation.bytes };
+  }
+  fail("parse_error", `No original state for planned write: ${mutation.label}`, { path: mutation.label, phase: "path" });
+}
+function fileExpectation(label, state) {
+  if (state.snapshot !== undefined) {
+    return { kind: "file", label, snapshot: state.snapshot };
+  }
+  fail("parse_error", `No original file state for planned mutation: ${label}`, { path: label, phase: "path" });
+}
+function mutationPath(paths, label) {
+  const state = paths.get(label);
+  if (state === undefined) {
+    fail("parse_error", `No resolved path for planned mutation: ${label}`, { path: label, phase: "path" });
+  }
+  return state;
+}
+function resultWithWriteFlag(result, dryRun) {
+  return {
+    ...result,
+    written: result.status === "applied" && !dryRun && result.changed.length > 0
+  };
+}
+function planMovePatch(effectivePatch, files) {
+  if (effectivePatch.src === null || effectivePatch.dst === null) {
+    if (effectivePatch.src === null && effectivePatch.dst !== null && !effectivePatch.hasSourceHunk) {
+      return planPathCreationMove(effectivePatch, effectivePatch.dst, files);
+    }
+    if (effectivePatch.dst === null && effectivePatch.src !== null && effectivePatch.hasSourceHunk) {
+      return planPathDeletionMove(effectivePatch, effectivePatch.src, files);
+    }
+    fail("parse_error", "Invalid /dev/null endpoint move shape");
+  }
+  if (!effectivePatch.hasSourceHunk) {
+    return planInFileInsertionMove(effectivePatch, effectivePatch.src, effectivePatch.dst, files);
+  }
+  if (effectivePatch.target === null) {
+    return planInFileDeletionMove(effectivePatch, effectivePatch.src, effectivePatch.dst, files);
+  }
+  return planPairedMove(effectivePatch, files);
+}
+function planPairedMove(patch, files) {
+  if (patch.src === null || patch.dst === null) {
+    fail("parse_error", "Paired move requires source and destination paths");
+  }
+  const srcLabel = patch.src;
+  const dstLabel = patch.dst;
+  const srcFile = readMemoryFile(files, srcLabel, "source file");
+  const sameFile = sameMemoryFile(files, srcLabel, dstLabel);
+  const dstFile = sameFile ? srcFile : readMemoryFile(files, dstLabel, "destination file");
+  const plan = selectMovePlan(srcFile, dstFile, patch, sameFile);
+  if (plan.status === "already_applied") {
+    return {
+      result: {
+        changed: [],
+        affected: unique([srcLabel, dstLabel]),
+        written: false,
+        noop: true,
+        status: "already_applied",
+        moves: [plan.details]
+      },
+      mutations: []
+    };
+  }
+  const selection = plan.selection;
+  const next = sameFile ? applyMove(srcFile, selection) : applyCrossFileMove(srcFile, dstFile, selection);
+  const changed = changedMoveLabels(srcLabel, dstLabel, sameFile, srcFile, dstFile, next);
+  return {
+    result: {
+      changed,
+      affected: unique([srcLabel, dstLabel]),
+      written: false,
+      noop: changed.length === 0,
+      status: changed.length === 0 ? "noop" : "applied",
+      moves: [
+        moveResultDetails({
+          id: patch.id,
+          src: srcLabel,
+          dst: dstLabel,
+          payloadSha256: patch.payloadSha256,
+          selection
+        })
+      ]
+    },
+    mutations: moveMutations(srcLabel, dstLabel, sameFile, srcFile, dstFile, next)
+  };
+}
+function reverseMovePatch(patch) {
+  const reversedTarget = patch.hasSourceHunk ? {
+    before: patch.sourceBefore,
+    after: patch.sourceAfter
+  } : null;
+  return {
+    ...patch,
+    src: patch.dst,
+    dst: patch.src,
+    hasSourceHunk: patch.target !== null,
+    sourceBefore: patch.target?.before ?? Buffer3.alloc(0),
+    sourcePayload: patch.sourcePayload,
+    sourceAfter: patch.target?.after ?? Buffer3.alloc(0),
+    target: reversedTarget
+  };
+}
+function planInFileInsertionMove(patch, srcLabel, dstLabel, files) {
+  const target = requireTarget(patch);
+  const original = readMemoryFile(files, dstLabel, "destination file");
+  const alreadyApplied = findAlreadyAppliedTargetSelection(original, patch, dstLabel);
+  if (alreadyApplied !== undefined) {
+    return {
+      result: oneSidedResult({
+        patch,
+        src: srcLabel,
+        dst: dstLabel,
+        changed: [],
+        status: "already_applied",
+        sourceRange: null,
+        targetRange: alreadyApplied.range,
+        insertIndex: alreadyApplied.insertIndex
+      }),
+      mutations: []
+    };
+  }
+  const selection = findTargetSelection(original, target.before, target.after, dstLabel, {
+    phase: "target",
+    anchor: "blockpatch-target"
+  });
+  const next = Buffer3.concat([
+    original.subarray(0, selection.insertIndex),
+    patch.sourcePayload,
+    original.subarray(selection.insertIndex)
+  ]);
+  const changed = next.equals(original) ? [] : unique([srcLabel, dstLabel]);
+  return {
+    result: oneSidedResult({
+      patch,
+      src: srcLabel,
+      dst: dstLabel,
+      changed,
+      status: changed.length === 0 ? "noop" : "applied",
+      sourceRange: null,
+      targetRange: selection.range,
+      insertIndex: selection.insertIndex
+    }),
+    mutations: changed.length === 0 ? [] : [{ kind: "write", label: dstLabel, bytes: next }]
+  };
+}
+function planInFileDeletionMove(patch, srcLabel, dstLabel, files) {
+  const original = readMemoryFile(files, srcLabel, "source file");
+  const source = findDeletionSourceRange(original, patch, srcLabel);
+  if (source === undefined) {
+    return {
+      result: oneSidedResult({
+        patch,
+        src: srcLabel,
+        dst: dstLabel,
+        changed: [],
+        status: "already_applied",
+        sourceRange: null,
+        targetRange: null,
+        insertIndex: null
+      }),
+      mutations: []
+    };
+  }
+  const next = Buffer3.concat([original.subarray(0, source.start), original.subarray(source.end)]);
+  const changed = next.equals(original) ? [] : unique([srcLabel, dstLabel]);
+  return {
+    result: oneSidedResult({
+      patch,
+      src: srcLabel,
+      dst: dstLabel,
+      changed,
+      status: changed.length === 0 ? "noop" : "applied",
+      sourceRange: source,
+      targetRange: null,
+      insertIndex: null
+    }),
+    mutations: changed.length === 0 ? [] : [{ kind: "write", label: srcLabel, bytes: next }]
+  };
+}
+function oneSidedResult(args) {
+  return {
+    changed: args.changed,
+    affected: unique([args.src, args.dst]),
+    written: false,
+    noop: args.status !== "applied" || args.changed.length === 0,
+    status: args.status,
+    moves: [
+      {
+        id: args.patch.id,
+        src: args.src,
+        dst: args.dst,
+        payload_sha256: args.patch.payloadSha256,
+        payload_bytes: args.patch.sourcePayload.length,
+        source_range: args.sourceRange,
+        target_range: args.targetRange,
+        insert_index: args.insertIndex
+      }
+    ]
+  };
+}
+function planPathCreationMove(patch, dstLabel, files) {
+  const fullTarget = fullTargetBytes(patch);
+  const original = files.get(dstLabel)?.bytes;
+  if (original !== undefined) {
+    if (original.equals(fullTarget)) {
+      return {
+        result: nullSourceResult(patch, dstLabel, "already_applied", { start: 0, end: original.length }, 0),
+        mutations: []
+      };
+    }
+    fail("destination_exists", `Destination path for file creation already exists with different bytes: ${dstLabel}`, {
+      path: dstLabel,
+      phase: "target",
+      anchor: "blockpatch-target"
+    });
+  }
+  return {
+    result: nullSourceResult(patch, dstLabel, "applied", { start: 0, end: 0 }, 0),
+    mutations: [{ kind: "write", label: dstLabel, bytes: fullTarget, create: true }]
+  };
+}
+function planPathDeletionMove(patch, srcLabel, files) {
+  const original = files.get(srcLabel)?.bytes;
+  if (original === undefined) {
+    return {
+      result: nullTargetResult(patch, srcLabel, "already_applied", null),
+      mutations: []
+    };
+  }
+  const fullSource = Buffer3.concat([patch.sourceBefore, patch.sourcePayload, patch.sourceAfter]);
+  if (!original.equals(fullSource)) {
+    fail("source_not_found", `Whole-file source payload was not found in ${srcLabel}`, {
+      path: srcLabel,
+      phase: "source",
+      anchor: "blockpatch-source",
+      matches: 0
+    });
+  }
+  return {
+    result: nullTargetResult(patch, srcLabel, "applied", {
+      start: patch.sourceBefore.length,
+      end: patch.sourceBefore.length + patch.sourcePayload.length
+    }),
+    mutations: [{ kind: "delete", label: srcLabel }]
+  };
+}
+function fullTargetBytes(patch) {
+  const target = requireTarget(patch);
+  return Buffer3.concat([target.before, patch.sourcePayload, target.after]);
+}
+function requireTarget(patch) {
+  if (patch.target === null) {
+    fail("parse_error", "Patch shape requires a blockpatch-target hunk");
+  }
+  return patch.target;
+}
+function findDeletionSourceRange(file, patch, srcLabel) {
+  const fullSource = Buffer3.concat([patch.sourceBefore, patch.sourcePayload, patch.sourceAfter]);
+  const fullMatchResult = indexesOfLimited(file, fullSource);
+  const fullMatches = fullMatchResult.matches;
+  if (fullMatches.length === 1 && !fullMatchResult.truncated) {
+    const start = fullMatches[0] + patch.sourceBefore.length;
+    return { start, end: start + patch.sourcePayload.length };
+  }
+  if (fullMatches.length > 1 || fullMatchResult.truncated) {
+    fail("source_ambiguous", `Source block is ambiguous in ${srcLabel}; ${matchedLocations(fullMatches.length, fullMatchResult.truncated)}`, {
+      path: srcLabel,
+      phase: "source",
+      anchor: "blockpatch-source",
+      ...matchCountDetails(fullMatches.length, fullMatchResult.truncated),
+      ranges: boundedMatchRanges(fullMatches, fullSource.length),
+      line_ranges: boundedMatchLineRanges(file, fullMatches, fullSource.length)
+    });
+  }
+  return deletionAlreadyAppliedOrFail(file, patch, srcLabel);
+}
+function deletionAlreadyAppliedOrFail(file, patch, srcLabel) {
+  const anchorless = patch.sourceBefore.length === 0 && patch.sourceAfter.length === 0;
+  if (anchorless) {
+    return;
+  }
+  const adjacent = Buffer3.concat([patch.sourceBefore, patch.sourceAfter]);
+  const adjacentMatchResult = indexesOfLimitedWhere(file, adjacent, (start) => isDeletionAlreadyAppliedMatch(file, patch, start));
+  const adjacentMatches = adjacentMatchResult.matches;
+  if (adjacentMatches.length === 1 && !adjacentMatchResult.truncated) {
+    return;
+  }
+  if (adjacentMatches.length > 1 || adjacentMatchResult.truncated) {
+    fail("source_ambiguous", `Already-deleted source anchors are ambiguous in ${srcLabel}`, {
+      path: srcLabel,
+      phase: "source",
+      anchor: "blockpatch-source",
+      ...matchCountDetails(adjacentMatches.length, adjacentMatchResult.truncated),
+      ranges: boundedMatchRanges(adjacentMatches, adjacent.length),
+      line_ranges: boundedMatchLineRanges(file, adjacentMatches, adjacent.length)
+    });
+  }
+  const envelopes = findSourceEnvelopes(file, patch);
+  if (envelopes.ranges.length === 1 && !envelopes.truncated) {
+    fail("payload_mismatch", `Source payload does not match located source anchors in ${srcLabel}`, {
+      path: srcLabel,
+      phase: "payload",
+      anchor: "blockpatch-source"
+    });
+  }
+  if (envelopes.ranges.length > 1 || envelopes.truncated) {
+    fail("source_ambiguous", `Source anchors are ambiguous in ${srcLabel}; ${matchedLocations(envelopes.ranges.length, envelopes.truncated)}`, {
+      path: srcLabel,
+      phase: "source",
+      anchor: "blockpatch-source",
+      ...matchCountDetails(envelopes.ranges.length, envelopes.truncated),
+      ranges: boundedRanges(envelopes.ranges),
+      line_ranges: boundedLineRanges(file, envelopes.ranges)
+    });
+  }
+  fail("source_not_found", `Source anchors were not found in ${srcLabel}`, {
+    path: srcLabel,
+    phase: "source",
+    anchor: "blockpatch-source",
+    matches: 0
+  });
+}
+function isDeletionAlreadyAppliedMatch(file, patch, start) {
+  if (patch.sourceBefore.length === 0) {
+    return start === 0;
+  }
+  if (patch.sourceAfter.length === 0) {
+    return start + patch.sourceBefore.length === file.length;
+  }
+  return true;
+}
+function nullSourceResult(patch, dstLabel, status, targetRange, insertIndex) {
+  const applied = status === "applied";
+  return {
+    changed: applied ? [dstLabel] : [],
+    affected: [dstLabel],
+    written: false,
+    noop: !applied,
+    status,
+    moves: [
+      {
+        id: patch.id,
+        src: devNull,
+        dst: dstLabel,
+        payload_sha256: patch.payloadSha256,
+        payload_bytes: patch.sourcePayload.length,
+        source_range: null,
+        target_range: targetRange,
+        insert_index: insertIndex
+      }
+    ]
+  };
+}
+function nullTargetResult(patch, srcLabel, status, sourceRange) {
+  const applied = status === "applied";
+  return {
+    changed: applied ? [srcLabel] : [],
+    affected: [srcLabel],
+    written: false,
+    noop: !applied,
+    status,
+    moves: [
+      {
+        id: patch.id,
+        src: srcLabel,
+        dst: devNull,
+        payload_sha256: patch.payloadSha256,
+        payload_bytes: patch.sourcePayload.length,
+        source_range: sourceRange,
+        target_range: null,
+        insert_index: null
+      }
+    ]
+  };
+}
+function selectMovePlan(srcFile, dstFile, patch, sameFile) {
+  const srcLabel = patch.src ?? devNull;
+  const dstLabel = patch.dst ?? devNull;
+  const targetAnchor = requireTarget(patch);
+  const source = findSourceRange(srcFile, dstFile, patch);
+  if (source === undefined) {
+    const target2 = findAlreadyAppliedTargetSelection(dstFile, patch);
+    if (target2 === undefined) {
+      fail("source_not_found", `Source anchors were not found in ${srcLabel}`, {
+        path: srcLabel,
+        phase: "source",
+        anchor: "blockpatch-source",
+        matches: 0
+      });
+    }
+    return {
+      status: "already_applied",
+      details: alreadyAppliedMoveResultDetails({
+        id: patch.id,
+        src: srcLabel,
+        dst: dstLabel,
+        payloadSha256: patch.payloadSha256,
+        payload: patch.sourcePayload,
+        target: target2
+      })
+    };
+  }
+  if (!sameFile) {
+    const alreadyAppliedTarget = findAlreadyAppliedTargetSelection(dstFile, patch, dstLabel);
+    if (alreadyAppliedTarget !== undefined) {
+      failPartialAppliedDuplicate(srcLabel, dstLabel, patch, source, alreadyAppliedTarget);
+    }
+  }
+  const target = findTargetSelection(dstFile, targetAnchor.before, targetAnchor.after, dstLabel, {
+    phase: "target",
+    anchor: "blockpatch-target"
+  });
+  return {
+    status: "pending",
+    selection: buildMoveSelection(srcFile, source, target, sameFile, dstLabel)
+  };
+}
+function failPartialAppliedDuplicate(srcLabel, dstLabel, patch, source, target) {
+  fail("partial_applied_duplicate", `Cross-file move appears partially applied: ${dstLabel} already contains the moved payload while ${srcLabel} still contains it`, {
+    path: dstLabel,
+    phase: "target",
+    anchor: "blockpatch-target",
+    source_range: source,
+    target_range: target.range,
+    payload_sha256: patch.payloadSha256,
+    suggested_action: "review_then_remove_source"
+  });
+}
+function buildMoveSelection(srcFile, source, target, sameFile, dstLabel) {
+  if (sameFile && rangesOverlap(source, target.range)) {
+    fail("target_overlaps_source", `Target anchor for ${dstLabel} overlaps the source block`, {
+      path: dstLabel,
+      phase: "target",
+      anchor: "blockpatch-target"
+    });
+  }
+  return {
+    source,
+    target,
+    payload: Buffer3.from(srcFile.subarray(source.start, source.end))
+  };
+}
+async function commitMove(args) {
+  const next = args.sameFile ? applyMove(args.srcOriginal, args.selection) : applyCrossFileMove(args.srcOriginal, args.dstOriginal, args.selection);
+  const srcChanged = !next.src.equals(args.srcOriginal);
+  const dstChanged = !args.sameFile && !next.dst.equals(args.dstOriginal);
+  const sameFileAlias = args.sameFile && args.srcPath !== args.dstPath;
+  if (!args.dryRun) {
+    const writes = [];
+    if (dstChanged || sameFileAlias && srcChanged) {
+      writes.push({
+        path: args.dstPath,
+        bytes: next.dst,
+        label: args.dstLabel,
+        expected: args.dstSnapshot === undefined ? undefined : { kind: "file", label: args.dstLabel, snapshot: args.dstSnapshot }
+      });
+    }
+    if (srcChanged) {
+      writes.push({
+        path: args.srcPath,
+        bytes: next.src,
+        label: args.srcLabel,
+        expected: args.srcSnapshot === undefined ? undefined : { kind: "file", label: args.srcLabel, snapshot: args.srcSnapshot }
+      });
+    }
+    await writeAtomically(writes);
+  }
+  const changed = [];
+  if (srcChanged) {
+    changed.push(args.srcLabel);
+    if (sameFileAlias) {
+      changed.push(args.dstLabel);
+    }
+  }
+  if (dstChanged) {
+    changed.push(args.dstLabel);
+  }
+  return unique(changed);
+}
+function applyMove(file, selection) {
+  const withoutSource = Buffer3.concat([
+    file.subarray(0, selection.source.start),
+    file.subarray(selection.source.end)
+  ]);
+  const targetIndex = selection.target.insertIndex >= selection.source.end ? selection.target.insertIndex - selection.payload.length : selection.target.insertIndex;
+  const next = Buffer3.concat([
+    withoutSource.subarray(0, targetIndex),
+    selection.payload,
+    withoutSource.subarray(targetIndex)
+  ]);
+  return { src: next, dst: next };
+}
+function applyCrossFileMove(srcFile, dstFile, selection) {
+  return {
+    src: Buffer3.concat([srcFile.subarray(0, selection.source.start), srcFile.subarray(selection.source.end)]),
+    dst: Buffer3.concat([
+      dstFile.subarray(0, selection.target.insertIndex),
+      selection.payload,
+      dstFile.subarray(selection.target.insertIndex)
+    ])
+  };
+}
+function findSourceRange(srcFile, dstFile, patch) {
+  const srcLabel = patch.src ?? devNull;
+  const fullSource = Buffer3.concat([patch.sourceBefore, patch.sourcePayload, patch.sourceAfter]);
+  const fullMatchResult = indexesOfLimited(srcFile, fullSource);
+  const fullMatches = fullMatchResult.matches;
+  if (fullMatches.length === 1 && !fullMatchResult.truncated) {
+    const start = fullMatches[0] + patch.sourceBefore.length;
+    return { start, end: start + patch.sourcePayload.length };
+  }
+  if (fullMatches.length > 1 || fullMatchResult.truncated) {
+    fail("source_ambiguous", `Source block is ambiguous in ${srcLabel}; ${matchedLocations(fullMatches.length, fullMatchResult.truncated)}`, {
+      path: srcLabel,
+      phase: "source",
+      anchor: "blockpatch-source",
+      ...matchCountDetails(fullMatches.length, fullMatchResult.truncated),
+      ranges: boundedMatchRanges(fullMatches, fullSource.length),
+      line_ranges: boundedMatchLineRanges(srcFile, fullMatches, fullSource.length)
+    });
+  }
+  const alreadyApplied = findAlreadyAppliedTargetSelection(dstFile, patch);
+  if (alreadyApplied !== undefined) {
+    return;
+  }
+  const envelopes = findSourceEnvelopes(srcFile, patch);
+  if (envelopes.ranges.length === 1 && !envelopes.truncated) {
+    fail("payload_mismatch", `Source payload does not match located source anchors in ${srcLabel}`, {
+      path: srcLabel,
+      phase: "payload",
+      anchor: "blockpatch-source"
+    });
+  }
+  if (envelopes.ranges.length > 1 || envelopes.truncated) {
+    fail("source_ambiguous", `Source anchors are ambiguous in ${srcLabel}; ${matchedLocations(envelopes.ranges.length, envelopes.truncated)}`, {
+      path: srcLabel,
+      phase: "source",
+      anchor: "blockpatch-source",
+      ...matchCountDetails(envelopes.ranges.length, envelopes.truncated),
+      ranges: boundedRanges(envelopes.ranges),
+      line_ranges: boundedLineRanges(srcFile, envelopes.ranges)
+    });
+  }
+  fail("source_not_found", `Source anchors were not found in ${srcLabel}`, {
+    path: srcLabel,
+    phase: "source",
+    anchor: "blockpatch-source",
+    matches: 0
+  });
+}
+function findAlreadyAppliedTargetSelection(file, patch, dstLabel = patch.dst ?? devNull) {
+  const target = requireTarget(patch);
+  const alreadyApplied = Buffer3.concat([target.before, patch.sourcePayload, target.after]);
+  const matchResult = indexesOfLimited(file, alreadyApplied);
+  const matches = matchResult.matches;
+  if (matches.length === 0) {
+    return;
+  }
+  if (matches.length > 1 || matchResult.truncated) {
+    fail("target_ambiguous", `Already-applied target is ambiguous in ${dstLabel}; ${matchedLocations(matches.length, matchResult.truncated)}`, {
+      path: dstLabel,
+      phase: "target",
+      anchor: "blockpatch-target",
+      ...matchCountDetails(matches.length, matchResult.truncated),
+      ranges: boundedMatchRanges(matches, alreadyApplied.length),
+      line_ranges: boundedMatchLineRanges(file, matches, alreadyApplied.length)
+    });
+  }
+  const start = matches[0];
+  return {
+    range: { start, end: start + alreadyApplied.length },
+    insertIndex: start + target.before.length
+  };
+}
+function findSourceEnvelopes(file, patch, limit = 11) {
+  if (patch.sourceBefore.length === 0 || patch.sourceAfter.length === 0) {
+    return { ranges: [], truncated: false };
+  }
+  const maxMatches = normalizedLimit(limit);
+  const ranges = [];
+  let beforeStart = file.indexOf(patch.sourceBefore);
+  while (beforeStart !== -1) {
+    const payloadStart = beforeStart + patch.sourceBefore.length;
+    const afterStart = file.indexOf(patch.sourceAfter, payloadStart);
+    if (afterStart !== -1) {
+      if (ranges.length >= maxMatches) {
+        return { ranges, truncated: true };
+      }
+      ranges.push({ start: payloadStart, end: afterStart });
+    }
+    beforeStart = file.indexOf(patch.sourceBefore, beforeStart + 1);
+  }
+  return { ranges, truncated: false };
+}
+function findTargetSelection(file, before, after, dstLabel, details = {}) {
+  const anchor = Buffer3.concat([before, after]);
+  const matchResult = indexesOfLimited(file, anchor);
+  const matches = matchResult.matches;
+  if (matches.length === 0) {
+    fail("target_not_found", `Target anchor was not found in ${dstLabel}`, {
+      path: dstLabel,
+      ...details,
+      matches: 0
+    });
+  }
+  if (matches.length > 1 || matchResult.truncated) {
+    fail("target_ambiguous", `Target anchor is ambiguous in ${dstLabel}; ${matchedLocations(matches.length, matchResult.truncated)}`, {
+      path: dstLabel,
+      ...details,
+      ...matchCountDetails(matches.length, matchResult.truncated),
+      ranges: boundedMatchRanges(matches, anchor.length),
+      line_ranges: boundedMatchLineRanges(file, matches, anchor.length)
+    });
+  }
+  const start = matches[0];
+  return {
+    range: { start, end: start + anchor.length },
+    insertIndex: start + before.length
+  };
+}
+function indexesOfLimited(haystack, needle, limit = 11) {
+  if (needle.length === 0) {
+    return { matches: [], truncated: false };
+  }
+  const maxMatches = normalizedLimit(limit);
+  const matches = [];
+  let index = haystack.indexOf(needle);
+  while (index !== -1) {
+    if (matches.length >= maxMatches) {
+      return { matches, truncated: true };
+    }
+    matches.push(index);
+    index = haystack.indexOf(needle, index + 1);
+  }
+  return { matches, truncated: false };
+}
+function indexesOfLimitedWhere(haystack, needle, predicate, limit = 11) {
+  if (needle.length === 0) {
+    return { matches: [], truncated: false };
+  }
+  const maxMatches = normalizedLimit(limit);
+  const matches = [];
+  let index = haystack.indexOf(needle);
+  while (index !== -1) {
+    if (predicate(index)) {
+      if (matches.length >= maxMatches) {
+        return { matches, truncated: true };
+      }
+      matches.push(index);
+    }
+    index = haystack.indexOf(needle, index + 1);
+  }
+  return { matches, truncated: false };
+}
+function normalizedLimit(limit) {
+  if (!Number.isFinite(limit)) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return Math.max(0, Math.trunc(limit));
+}
+function rangesOverlap(left, right) {
+  return left.start < right.end && right.start < left.end;
+}
+function moveResultDetails(args) {
+  return {
+    id: args.id,
+    src: args.src,
+    dst: args.dst,
+    payload_sha256: args.payloadSha256,
+    payload_bytes: args.selection.payload.length,
+    source_range: args.selection.source,
+    target_range: args.selection.target.range,
+    insert_index: args.selection.target.insertIndex
+  };
+}
+function alreadyAppliedMoveResultDetails(args) {
+  return {
+    id: args.id,
+    src: args.src,
+    dst: args.dst,
+    payload_sha256: args.payloadSha256,
+    payload_bytes: args.payload.length,
+    source_range: null,
+    target_range: args.target.range,
+    insert_index: args.target.insertIndex
+  };
+}
+function unique(paths) {
+  return [...new Set(paths)];
+}
+function changedMoveLabels(srcLabel, dstLabel, sameFile, srcOriginal, dstOriginal, next) {
+  const srcChanged = !next.src.equals(srcOriginal);
+  const dstChanged = !sameFile && !next.dst.equals(dstOriginal);
+  const sameFileAlias = sameFile && srcLabel !== dstLabel;
+  const changed = [];
+  if (srcChanged) {
+    changed.push(srcLabel);
+    if (sameFileAlias) {
+      changed.push(dstLabel);
+    }
+  }
+  if (dstChanged) {
+    changed.push(dstLabel);
+  }
+  return unique(changed);
+}
+function moveMutations(srcLabel, dstLabel, sameFile, srcOriginal, dstOriginal, next) {
+  const srcChanged = !next.src.equals(srcOriginal);
+  const dstChanged = !sameFile && !next.dst.equals(dstOriginal);
+  const sameFileAlias = sameFile && srcLabel !== dstLabel;
+  const mutations = [];
+  if (dstChanged || sameFileAlias && srcChanged) {
+    mutations.push({ kind: "write", label: dstLabel, bytes: next.dst });
+  }
+  if (srcChanged) {
+    mutations.push({ kind: "write", label: srcLabel, bytes: next.src });
+  }
+  return mutations;
+}
+function memoryFileMap(files) {
+  const mapped = new Map;
+  for (const file of files) {
+    if (mapped.has(file.path)) {
+      fail("parse_error", `Duplicate in-memory file: ${file.path}`, { path: file.path, phase: "check" });
+    }
+    mapped.set(file.path, {
+      bytes: file.bytes,
+      identity: file.identity ?? file.path
+    });
+  }
+  return mapped;
+}
+function readMemoryFile(files, path, label) {
+  const file = files.get(path);
+  if (file === undefined) {
+    fail("file_not_found", `Could not read ${label}: ${path}`, { path, phase: "io" });
+  }
+  return file.bytes;
+}
+function sameMemoryFile(files, left, right) {
+  if (left === right) {
+    return true;
+  }
+  const leftFile = files.get(left);
+  const rightFile = files.get(right);
+  return leftFile !== undefined && rightFile !== undefined && leftFile.identity === rightFile.identity;
+}
+async function writeAtomic(path, bytes, options = {}) {
+  await writeAtomically([
+    {
+      path,
+      bytes,
+      create: options.create,
+      expected: options.expected,
+      label: options.label
+    }
+  ]);
+}
+async function writeAtomically(writes, deletes = []) {
+  const staged = [];
+  try {
+    for (const write of writes) {
+      staged.push(await stageAtomicWrite(write));
+    }
+    const decisions = [];
+    for (const write of staged) {
+      decisions.push(await verifyStagedWrite(write));
+    }
+    for (const deletion of deletes) {
+      await verifyAtomicDelete(deletion);
+    }
+    for (const [index, write] of staged.entries()) {
+      if (decisions[index] === "skip") {
+        await cleanupStagedWrite(write);
+        continue;
+      }
+      try {
+        await rename(write.temp, write.path);
+      } catch (error) {
+        failFileSystem(error, write.path, "Could not replace file");
+      }
+    }
+    for (const deletion of deletes) {
+      try {
+        await unlink(deletion.path);
+      } catch (error) {
+        failFileSystem(error, deletion.path, "Could not remove file");
+      }
+    }
+  } catch (error) {
+    await cleanupStagedWrites(staged);
+    throw error;
+  }
+}
+async function verifyStagedWrite(write) {
+  const expected = write.request.expected;
+  if (expected === undefined) {
+    return "rename";
+  }
+  if (expected.kind === "missing") {
+    const current2 = await readFileSnapshotOptional(write.path, expected.label);
+    if (current2 === undefined) {
+      return "rename";
+    }
+    if (expected.bytesIfExists !== undefined && current2.bytes.equals(expected.bytesIfExists)) {
+      return "skip";
+    }
+    failConcurrentModification(expected.label);
+  }
+  const current = await readFileSnapshotOptional(write.path, expected.label);
+  if (current === undefined || !sameFileSnapshot(expected.snapshot, current)) {
+    failConcurrentModification(expected.label);
+  }
+  return "rename";
+}
+async function verifyAtomicDelete(deletion) {
+  const expected = deletion.expected;
+  if (expected === undefined) {
+    return;
+  }
+  if (expected.kind === "missing") {
+    const current2 = await readFileSnapshotOptional(deletion.path, expected.label);
+    if (current2 === undefined) {
+      return;
+    }
+    failConcurrentModification(expected.label);
+  }
+  const current = await readFileSnapshotOptional(deletion.path, expected.label);
+  if (current === undefined || !sameFileSnapshot(expected.snapshot, current)) {
+    failConcurrentModification(expected.label);
+  }
+}
+async function readFileSnapshotOptional(path, label) {
+  try {
+    return await readFileSnapshot(path, "current file");
+  } catch (error) {
+    if (error instanceof BlockPatchError && error.code === "file_not_found") {
+      return;
+    }
+    if (error instanceof BlockPatchError && error.code === "not_regular_file") {
+      failConcurrentModification(label);
+    }
+    throw error;
+  }
+}
+function sameFileSnapshot(left, right) {
+  return left.sha256 === right.sha256 && sameStatSnapshot(left.stat, right.stat);
+}
+function sameStatSnapshot(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+function failConcurrentModification(label) {
+  fail("concurrent_modification", `File changed after blockpatch verified its input: ${label}`, {
+    path: label,
+    phase: "write"
+  });
+}
+async function stageAtomicWrite(write) {
+  let mode;
+  let createMissing = false;
+  if (write.create === true) {
+    const info = await statOptional(write.path);
+    if (info !== undefined) {
+      assertExpectedRegularFile(info, write.path, "output file", write.expected);
+      mode = info.mode;
+    }
+    if (mode === undefined) {
+      createMissing = true;
+      mode = 420;
+    }
+  } else {
+    const info = await statOptional(write.path);
+    if (info === undefined) {
+      if (write.expected !== undefined) {
+        failConcurrentModification(write.expected.label);
+      }
+      fail("file_not_found", `Could not stat output file: ${write.path}`, { path: write.path, phase: "io" });
+    }
+    assertExpectedRegularFile(info, write.path, "output file", write.expected);
+    mode = info.mode;
+  }
+  const dir = dirname(write.path);
+  const base = basename(write.path);
+  const temp = join2(dir, `.${base}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+  let createdDirectory;
+  try {
+    if (createMissing) {
+      const firstCreated = await mkdir(dir, { recursive: true });
+      if (firstCreated !== undefined) {
+        createdDirectory = { first: firstCreated, target: dir };
+      }
+    }
+    await assertSafeOutputParentDirectory(dir, write.path);
+    await writeFile(temp, write.bytes, { flag: "wx" });
+    if (mode !== undefined) {
+      await chmod(temp, mode);
+    }
+  } catch (error) {
+    await cleanupStagedWrite({ temp, createdDirectory });
+    failFileSystem(error, write.path, "Could not stage file replacement");
+  }
+  return { path: write.path, temp, request: write, createdDirectory };
+}
+async function assertSafeOutputParentDirectory(dir, outputPath) {
+  let info;
+  try {
+    info = await lstat(dir);
+  } catch (error) {
+    failFileSystem(error, outputPath, "Could not stat output directory", "path");
+  }
+  if (info.isSymbolicLink()) {
+    fail("symlink_path", `output directory must not be a symbolic link: ${outputPath}`, {
+      path: outputPath,
+      phase: "path"
+    });
+  }
+  if (!info.isDirectory()) {
+    fail("not_regular_file", `output directory must be a directory: ${outputPath}`, {
+      path: outputPath,
+      phase: "path"
+    });
+  }
+}
+async function cleanupStagedWrites(staged) {
+  await Promise.all(staged.map((write) => unlink(write.temp).catch(() => {
+    return;
+  })));
+  for (const write of [...staged].reverse()) {
+    await cleanupCreatedDirectoryChain(write.createdDirectory);
+  }
+}
+async function cleanupStagedWrite(write) {
+  await unlink(write.temp).catch(() => {
+    return;
+  });
+  await cleanupCreatedDirectoryChain(write.createdDirectory);
+}
+async function cleanupCreatedDirectoryChain(chain) {
+  if (chain === undefined || !isSameOrChildPath(chain.target, chain.first)) {
+    return;
+  }
+  let current = chain.target;
+  while (true) {
+    try {
+      await rmdir(current);
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT") {
+        return;
+      }
+    }
+    if (resolve2(current) === resolve2(chain.first)) {
+      return;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+}
+function isSameOrChildPath(child, parent) {
+  const childFromParent = relative2(resolve2(parent), resolve2(child));
+  return childFromParent === "" || childFromParent !== ".." && !childFromParent.startsWith(`..${sep2}`) && !isAbsolute2(childFromParent);
+}
+function assertExpectedRegularFile(info, path, label, expected) {
+  if (!info.isFile() && expected !== undefined) {
+    failConcurrentModification(expected.label);
+  }
+  assertRegularFile(info, path, label);
+}
+async function statOptional(path) {
+  try {
+    return await stat2(path);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return;
+    }
+    failFileSystem(error, path, "Could not stat output file");
+  }
+}
+
+// src/move.ts
+import { createHash as createHash3 } from "node:crypto";
+import { posix as posix2 } from "node:path";
+import { TextDecoder } from "node:util";
+var moveArgTypes = {
+  src: "string",
+  src_start: "string",
+  src_end: "string",
+  dst: "string",
+  payload: "string",
+  target_before: "string",
+  target_after: "string",
+  expected_payload_sha256: "string",
+  mode: "string",
+  dry_run: "boolean"
+};
+var moveModes = new Set(["create_file", "remove_file"]);
+var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+async function moveBlock(args, options = {}) {
+  const validated = validateMoveArgs(args);
+  const normalized = normalizeArgs(validated);
+  const cwd = options.cwd ?? process.cwd();
+  const dryRun = options.dryRun ?? validated.dry_run ?? false;
+  if (normalized.kind === "create_file") {
+    return createFile(normalized, validated, cwd, dryRun, options);
+  }
+  if (normalized.kind === "remove_file") {
+    return removeFile(normalized, validated, cwd, dryRun, options);
+  }
+  if (normalized.kind === "insertion") {
+    return insertPayload(normalized, validated, cwd, dryRun, options);
+  }
+  if (normalized.kind === "deletion") {
+    return deletePayload(normalized, validated, cwd, dryRun, options);
+  }
+  const srcPath = resolvePath(cwd, normalized.src, "source path");
+  const dstPath = resolvePath(cwd, normalized.dst, "destination path");
+  const sameFile = await sameFileIdentity(srcPath, dstPath);
+  const srcSnapshot = await readFileSnapshot(srcPath, "source file");
+  const dstSnapshot = sameFile ? srcSnapshot : await readFileSnapshot(dstPath, "destination file");
+  const srcOriginal = srcSnapshot.bytes;
+  const dstOriginal = dstSnapshot.bytes;
+  const source = findSource(srcOriginal, normalized);
+  const target = findTargetSelection(dstOriginal, normalized.targetBefore, normalized.targetAfter, normalized.dst, {
+    phase: "target",
+    anchor: targetAnchorName(normalized)
+  });
+  const selection = buildMoveSelection(srcOriginal, source, target, sameFile, normalized.dst);
+  const payloadSha256 = createHash3("sha256").update(selection.payload).digest("hex");
+  verifyExpectedPayloadHash(validated, payloadSha256);
+  const samePatchLabel = samePatchPath2(normalized.src, normalized.dst);
+  const patch = options.diff ? renderMovePatch(normalized, srcOriginal, dstOriginal, selection, sameFile && samePatchLabel, payloadSha256) : undefined;
+  await selfCheckRenderedPatch(patch, pairedSelfCheckFiles(normalized.src, normalized.dst, srcOriginal, dstOriginal, sameFile));
+  const writeSuppressed = dryRun || options.diff === true;
+  const changed = await commitMove({
+    srcPath,
+    dstPath,
+    sameFile,
+    dryRun: writeSuppressed,
+    srcOriginal,
+    dstOriginal,
+    srcSnapshot,
+    dstSnapshot,
+    selection,
+    srcLabel: normalized.src,
+    dstLabel: normalized.dst
+  });
+  return {
+    changed,
+    affected: unique([normalized.src, normalized.dst]),
+    written: !writeSuppressed && changed.length > 0,
+    noop: changed.length === 0,
+    status: changed.length === 0 ? "noop" : "applied",
+    moves: [
+      moveResultDetails({
+        id: "move-1",
+        src: normalized.src,
+        dst: normalized.dst,
+        payloadSha256,
+        selection
+      })
+    ],
+    patch
+  };
+}
+function validateMoveArgs(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    fail("invalid_move_args", "move arguments must be a JSON object");
+  }
+  for (const [key, fieldValue] of Object.entries(value)) {
+    const expected = moveArgTypes[key];
+    if (expected === undefined) {
+      fail("invalid_move_args", `Unknown move argument: ${key}`, { field: key });
+    }
+    if (typeof fieldValue !== expected) {
+      fail("invalid_move_args", `move argument ${key} must be a ${expected}`, { field: key });
+    }
+  }
+  const args = value;
+  if (args.expected_payload_sha256 !== undefined && !/^[a-f0-9]{64}$/.test(args.expected_payload_sha256)) {
+    fail("invalid_move_args", "expected_payload_sha256 must be a 64-character lowercase sha256 hex digest", {
+      field: "expected_payload_sha256"
+    });
+  }
+  if (args.mode !== undefined && !moveModes.has(args.mode)) {
+    fail("invalid_move_args", "mode must be create_file or remove_file", { field: "mode" });
+  }
+  return args;
+}
+function normalizeArgs(args) {
+  if (!args.src) {
+    fail("invalid_move_args", "move requires src", { field: "src" });
+  }
+  if (args.src !== devNull) {
+    validateOperationPath(args.src, "source path");
+  }
+  if (args.dst !== undefined && args.dst !== devNull) {
+    validateOperationPath(args.dst, "destination path");
+  }
+  if (args.mode === "create_file") {
+    return normalizeFileCreationArgs(args);
+  }
+  if (args.mode === "remove_file") {
+    return normalizeFileRemovalArgs(args);
+  }
+  const dst = args.dst ?? args.src;
+  if (args.src === devNull && dst === devNull) {
+    fail("invalid_move_args", "move cannot use /dev/null for both src and dst", { field: "dst" });
+  }
+  if (args.src === devNull) {
+    if (args.dst === undefined) {
+      fail("invalid_move_args", "move from /dev/null requires dst", { field: "dst" });
+    }
+    if (args.src_start !== undefined || args.src_end !== undefined) {
+      fail("invalid_move_args", "move from /dev/null uses payload instead of src_start/src_end", {
+        field: args.src_start !== undefined ? "src_start" : "src_end"
+      });
+    }
+    if (args.payload === undefined) {
+      fail("invalid_move_args", "move from /dev/null requires payload", { field: "payload" });
+    }
+    if (args.payload.length === 0) {
+      fail("invalid_move_args", "move from /dev/null requires non-empty payload", { field: "payload" });
+    }
+    const target2 = normalizeTargetArgs(args);
+    return {
+      kind: "insertion",
+      src: devNull,
+      dst: args.dst,
+      payload: Buffer.from(args.payload, "utf8"),
+      targetBefore: target2.before,
+      targetAfter: target2.after
+    };
+  }
+  if (dst === devNull) {
+    if (args.payload !== undefined) {
+      fail("invalid_move_args", "move to /dev/null selects payload from src_start/src_end", { field: "payload" });
+    }
+    if (args.target_before !== undefined || args.target_after !== undefined) {
+      fail("invalid_move_args", "move to /dev/null must not include target anchors", {
+        field: args.target_before !== undefined ? "target_before" : "target_after"
+      });
+    }
+    return {
+      kind: "deletion",
+      src: args.src,
+      srcStart: requiredBuffer(args.src_start, "src_start"),
+      srcEnd: requiredBuffer(args.src_end, "src_end"),
+      dst: devNull
+    };
   }
+  if (args.payload !== undefined) {
+    fail("invalid_move_args", "payload is only valid when src is /dev/null", { field: "payload" });
+  }
+  const target = normalizeTargetArgs(args);
+  return {
+    kind: "relocation",
+    src: args.src,
+    srcStart: requiredBuffer(args.src_start, "src_start"),
+    srcEnd: requiredBuffer(args.src_end, "src_end"),
+    dst,
+    targetBefore: target.before,
+    targetAfter: target.after
+  };
 }
-function fail(code, message) {
-  throw new BlockPatchError(code, message);
+function normalizeFileCreationArgs(args) {
+  if (args.src !== devNull) {
+    fail("invalid_move_args", "create_file mode requires src to be /dev/null", { field: "src" });
+  }
+  if (args.dst === undefined) {
+    fail("invalid_move_args", "create_file mode requires dst", { field: "dst" });
+  }
+  if (args.dst === devNull) {
+    fail("invalid_move_args", "create_file mode cannot target /dev/null", { field: "dst" });
+  }
+  if (args.payload === undefined) {
+    fail("invalid_move_args", "create_file mode requires payload", { field: "payload" });
+  }
+  rejectSourceSelectionArgs(args, "create_file mode uses payload as the whole-file content");
+  rejectTargetAnchorArgs(args, "create_file mode must not include target anchors");
+  return {
+    kind: "create_file",
+    src: devNull,
+    dst: args.dst,
+    payload: Buffer.from(args.payload, "utf8")
+  };
 }
-
-// src/engine.ts
-import { randomBytes } from "node:crypto";
-import { chmod, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
-
-// src/parser.ts
-var beginLine = "*** Begin BlockPatch";
-var sourceBeforeLine = "*** Source Before";
-var sourcePayloadLine = "*** Source Payload";
-var sourceAfterLine = "*** Source After";
-var targetBeforeLine = "*** Target Before";
-var targetAfterLine = "*** Target After";
-var endLine = "*** End BlockPatch";
-var moveFilePrefix = "*** Move File: ";
-function parseBlockPatch(input) {
-  const markers = collectMarkers(input);
-  const sequence = markers.map((marker) => marker.name);
-  const targetIndex = sequence.findIndex((name) => name === "targetBefore" || name === "targetAfter");
-  if (targetIndex === -1) {
-    fail("parse_error", "Patch must contain *** Target Before or *** Target After");
-  }
-  const expectedPrefix = ["begin", "moveFile", "sourceBefore", "sourcePayload", "sourceAfter"];
-  const expectedSuffix = ["end"];
-  const expected = [...expectedPrefix, sequence[targetIndex], ...expectedSuffix];
-  if (sequence.length !== expected.length || sequence.some((name, index) => name !== expected[index])) {
-    fail("parse_error", "Patch markers must appear in the v0 order");
-  }
-  const moveFile = markers[1];
-  const path = moveFile.value?.trim();
-  if (!path) {
-    fail("parse_error", "*** Move File must include a path");
-  }
-  const sourceBefore = section(input, markers[2], markers[3]);
-  const sourcePayload = section(input, markers[3], markers[4]);
-  const sourceAfter = section(input, markers[4], markers[5]);
-  const targetAnchor = section(input, markers[5], markers[6]);
-  const target = {
-    kind: markers[5].name === "targetBefore" ? "before" : "after",
-    anchor: targetAnchor
-  };
-  if (sourceBefore.length === 0) {
-    fail("parse_error", "*** Source Before must not be empty");
-  }
-  if (sourcePayload.length === 0) {
-    fail("parse_error", "*** Source Payload must not be empty");
-  }
-  if (sourceAfter.length === 0) {
-    fail("parse_error", "*** Source After must not be empty");
-  }
-  if (target.anchor.length === 0) {
-    fail("parse_error", "*** Target Before/After must not be empty");
+function normalizeFileRemovalArgs(args) {
+  if (args.src === devNull) {
+    fail("invalid_move_args", "remove_file mode requires a real src path", { field: "src" });
   }
+  if (args.dst !== devNull) {
+    fail("invalid_move_args", "remove_file mode requires dst to be /dev/null", { field: "dst" });
+  }
+  if (args.payload !== undefined) {
+    fail("invalid_move_args", "remove_file mode reads the whole-file payload from src", { field: "payload" });
+  }
+  rejectSourceSelectionArgs(args, "remove_file mode removes the whole src file");
+  rejectTargetAnchorArgs(args, "remove_file mode must not include target anchors");
   return {
-    type: "move",
-    path,
-    sourceBefore,
-    sourcePayload,
-    sourceAfter,
-    target
+    kind: "remove_file",
+    src: args.src,
+    dst: devNull
   };
 }
-function collectMarkers(input) {
-  const markers = [];
-  let position = 0;
-  while (position <= input.length) {
-    const lineStart = position;
-    const lf = input.indexOf(10, position);
-    const lineEnd = lf === -1 ? input.length : lf;
-    const contentStart = lf === -1 ? input.length : lf + 1;
-    const textEnd = lineEnd > lineStart && input[lineEnd - 1] === 13 ? lineEnd - 1 : lineEnd;
-    const line = input.subarray(lineStart, textEnd).toString("utf8");
-    const marker = markerForLine(line, lineStart, contentStart);
-    if (marker !== undefined) {
-      markers.push(marker);
-    }
-    if (lf === -1) {
-      break;
-    }
-    position = lf + 1;
+function rejectSourceSelectionArgs(args, message) {
+  if (args.src_start !== undefined || args.src_end !== undefined) {
+    fail("invalid_move_args", message, {
+      field: args.src_start !== undefined ? "src_start" : "src_end"
+    });
   }
-  if (markers.length === 0) {
-    fail("parse_error", "Patch does not contain BlockPatch markers");
-  }
-  return markers;
-}
-function markerForLine(line, lineStart, contentStart) {
-  if (line === beginLine)
-    return { name: "begin", lineStart, contentStart };
-  if (line.startsWith(moveFilePrefix)) {
-    return { name: "moveFile", value: line.slice(moveFilePrefix.length), lineStart, contentStart };
-  }
-  if (line === sourceBeforeLine)
-    return { name: "sourceBefore", lineStart, contentStart };
-  if (line === sourcePayloadLine)
-    return { name: "sourcePayload", lineStart, contentStart };
-  if (line === sourceAfterLine)
-    return { name: "sourceAfter", lineStart, contentStart };
-  if (line === targetBeforeLine)
-    return { name: "targetBefore", lineStart, contentStart };
-  if (line === targetAfterLine)
-    return { name: "targetAfter", lineStart, contentStart };
-  if (line === endLine)
-    return { name: "end", lineStart, contentStart };
-  return;
 }
-function section(input, marker, nextMarker) {
-  let end = nextMarker.lineStart;
-  if (end > marker.contentStart && input[end - 1] === 10) {
-    end -= 1;
-    if (end > marker.contentStart && input[end - 1] === 13) {
-      end -= 1;
-    }
+function rejectTargetAnchorArgs(args, message) {
+  if (args.target_before !== undefined || args.target_after !== undefined) {
+    fail("invalid_move_args", message, {
+      field: args.target_before !== undefined ? "target_before" : "target_after"
+    });
   }
-  return Buffer.from(input.subarray(marker.contentStart, end));
 }
-
-// src/engine.ts
-async function checkPatchFile(patchPath, options = {}) {
-  return runPatchFile(patchPath, { ...options, dryRun: true });
+function normalizeTargetArgs(args) {
+  const hasTargetBefore = args.target_before !== undefined;
+  const hasTargetAfter = args.target_after !== undefined;
+  if (!hasTargetBefore && !hasTargetAfter) {
+    fail("invalid_move_args", "move requires target_before or target_after", { field: "target_before" });
+  }
+  const targetBefore = Buffer.from(args.target_before ?? "", "utf8");
+  const targetAfter = Buffer.from(args.target_after ?? "", "utf8");
+  if (targetBefore.length === 0 && targetAfter.length === 0) {
+    fail("invalid_move_args", "move requires non-empty target context", { field: "target_before" });
+  }
+  return { before: targetBefore, after: targetAfter };
 }
-async function applyPatchFile(patchPath, options = {}) {
-  return runPatchFile(patchPath, options);
+function requiredBuffer(value, field) {
+  if (!value) {
+    fail("invalid_move_args", `move requires ${field}`, { field });
+  }
+  return Buffer.from(value, "utf8");
 }
-async function runPatchFile(patchPath, options) {
-  const cwd = options.cwd ?? process.cwd();
-  const patchBytes = await readFile(resolve(cwd, patchPath));
-  const patch = parseBlockPatch(patchBytes);
-  const changedPath = await applyMovePatch(patch, cwd, options.dryRun ?? false);
-  return { changed: [changedPath] };
+async function createFile(args, validated, cwd, dryRun, options) {
+  const payloadSha256 = createHash3("sha256").update(args.payload).digest("hex");
+  verifyExpectedPayloadHash(validated, payloadSha256);
+  const patch = renderFileCreationPatch(args, payloadSha256);
+  return runRenderedPatch(patch, cwd, dryRun, options);
 }
-async function applyMovePatch(patch, cwd, dryRun) {
-  const absolutePath = resolve(cwd, patch.path);
-  const original = await readFile(absolutePath);
-  const selection = selectMove(original, patch);
-  const next = applyMove(original, selection);
-  if (!dryRun && !next.equals(original)) {
-    await writeAtomic(absolutePath, next);
-  }
-  return patch.path;
+async function removeFile(args, validated, cwd, dryRun, options) {
+  const srcPath = resolvePath(cwd, args.src, "source path");
+  const payload = await readFileChecked(srcPath, "source file");
+  const payloadSha256 = createHash3("sha256").update(payload).digest("hex");
+  verifyExpectedPayloadHash(validated, payloadSha256);
+  const patch = renderFileRemovalPatch(args, payload, payloadSha256);
+  return runRenderedPatch(patch, cwd, dryRun, options);
 }
-function selectMove(file, patch) {
-  const source = findSourceRange(file, patch);
-  const target = findTarget(file, patch);
-  if (rangesOverlap(source, target.range)) {
-    fail("target_overlaps_source", `Target anchor for ${patch.path} overlaps the source block`);
-  }
+async function runRenderedPatch(patch, cwd, dryRun, options) {
+  const writeSuppressed = dryRun || options.diff === true;
+  const result = await applyPatchBytes(Buffer.from(patch, "utf8"), { cwd, dryRun: writeSuppressed });
   return {
-    source,
-    target,
-    payload: Buffer.from(file.subarray(source.start, source.end))
+    ...result,
+    patch: options.diff === true ? patch : undefined
   };
 }
-function applyMove(file, selection) {
-  const withoutSource = Buffer.concat([
-    file.subarray(0, selection.source.start),
-    file.subarray(selection.source.end)
-  ]);
-  const targetIndex = selection.target.insertIndex > selection.source.end ? selection.target.insertIndex - selection.payload.length : selection.target.insertIndex;
-  return Buffer.concat([
-    withoutSource.subarray(0, targetIndex),
-    selection.payload,
-    withoutSource.subarray(targetIndex)
+async function insertPayload(args, validated, cwd, dryRun, options) {
+  const dstPath = resolvePath(cwd, args.dst, "destination path");
+  const snapshot = await readFileSnapshot(dstPath, "destination file");
+  const original = snapshot.bytes;
+  const payloadSha256 = createHash3("sha256").update(args.payload).digest("hex");
+  verifyExpectedPayloadHash(validated, payloadSha256);
+  const alreadyApplied = findAlreadyAppliedTarget(original, args, args.dst);
+  if (alreadyApplied !== undefined) {
+    const renderedPatch2 = options.diff ? renderInsertionPatch(args, original, alreadyApplied, payloadSha256) : undefined;
+    await selfCheckRenderedPatch(renderedPatch2, [{ path: args.dst, bytes: original }]);
+    return {
+      changed: [],
+      affected: [args.dst],
+      written: false,
+      noop: true,
+      status: "already_applied",
+      moves: [
+        {
+          id: "move-1",
+          src: devNull,
+          dst: args.dst,
+          payload_sha256: payloadSha256,
+          payload_bytes: args.payload.length,
+          source_range: null,
+          target_range: alreadyApplied.range,
+          insert_index: alreadyApplied.insertIndex
+        }
+      ],
+      patch: renderedPatch2
+    };
+  }
+  const target = findTargetSelection(original, args.targetBefore, args.targetAfter, args.dst, {
+    phase: "target",
+    anchor: targetAnchorName(args)
+  });
+  const renderedPatch = options.diff ? renderInsertionPatch(args, original, target, payloadSha256) : undefined;
+  await selfCheckRenderedPatch(renderedPatch, [{ path: args.dst, bytes: original }]);
+  const writeSuppressed = dryRun || options.diff === true;
+  const next = Buffer.concat([
+    original.subarray(0, target.insertIndex),
+    args.payload,
+    original.subarray(target.insertIndex)
   ]);
+  const changed = next.equals(original) ? [] : [args.dst];
+  if (!writeSuppressed && changed.length > 0) {
+    await writeAtomic(dstPath, next, {
+      expected: { kind: "file", label: args.dst, snapshot }
+    });
+  }
+  return {
+    changed,
+    affected: [args.dst],
+    written: !writeSuppressed && changed.length > 0,
+    noop: changed.length === 0,
+    status: changed.length === 0 ? "noop" : "applied",
+    moves: [
+      {
+        id: "move-1",
+        src: devNull,
+        dst: args.dst,
+        payload_sha256: payloadSha256,
+        payload_bytes: args.payload.length,
+        source_range: null,
+        target_range: target.range,
+        insert_index: target.insertIndex
+      }
+    ],
+    patch: renderedPatch
+  };
 }
-function findSourceRange(file, patch) {
-  const fullSource = Buffer.concat([patch.sourceBefore, patch.sourcePayload, patch.sourceAfter]);
-  const fullMatches = indexesOf(file, fullSource);
-  if (fullMatches.length === 1) {
-    const start = fullMatches[0] + patch.sourceBefore.length;
-    return { start, end: start + patch.sourcePayload.length };
+function verifyExpectedPayloadHash(args, payloadSha256) {
+  if (args.expected_payload_sha256 !== undefined && args.expected_payload_sha256 !== payloadSha256) {
+    fail("hash_mismatch", "expected_payload_sha256 does not match selected source payload", {
+      field: "expected_payload_sha256",
+      phase: "payload",
+      anchor: "expected_payload_sha256"
+    });
   }
-  if (fullMatches.length > 1) {
-    fail("source_ambiguous", `Source block is ambiguous in ${patch.path}; matched ${fullMatches.length} locations`);
+}
+function findAlreadyAppliedTarget(file, args, dstLabel) {
+  const alreadyApplied = Buffer.concat([args.targetBefore, args.payload, args.targetAfter]);
+  const matchResult = indexesOfLimited(file, alreadyApplied);
+  const matches = matchResult.matches;
+  if (matches.length === 0) {
+    return;
   }
-  const envelopes = findSourceEnvelopes(file, patch);
-  if (envelopes.length === 1) {
-    fail("payload_mismatch", `Source payload does not match located source anchors in ${patch.path}`);
+  if (matches.length > 1 || matchResult.truncated) {
+    const ranges = boundedRanges(matches.map((start2) => ({ start: start2, end: start2 + alreadyApplied.length })));
+    fail("target_ambiguous", `Already-applied target is ambiguous in ${dstLabel}; ${matchedLocations(matches.length, matchResult.truncated)}`, {
+      path: dstLabel,
+      phase: "target",
+      anchor: "target_before+payload+target_after",
+      ...matchCountDetails(matches.length, matchResult.truncated),
+      ranges,
+      line_ranges: boundedLineRanges(file, ranges)
+    });
+  }
+  const start = matches[0];
+  return {
+    range: { start, end: start + alreadyApplied.length },
+    insertIndex: start + args.targetBefore.length
+  };
+}
+async function deletePayload(args, validated, cwd, dryRun, options) {
+  const srcPath = resolvePath(cwd, args.src, "source path");
+  const snapshot = await readFileSnapshot(srcPath, "source file");
+  const original = snapshot.bytes;
+  const source = findSource(original, args);
+  const payload = Buffer.from(original.subarray(source.start, source.end));
+  const payloadSha256 = createHash3("sha256").update(payload).digest("hex");
+  verifyExpectedPayloadHash(validated, payloadSha256);
+  const renderedPatch = options.diff ? renderDeletionPatch(args, original, source, payload, payloadSha256) : undefined;
+  await selfCheckRenderedPatch(renderedPatch, [{ path: args.src, bytes: original }]);
+  const writeSuppressed = dryRun || options.diff === true;
+  const next = Buffer.concat([original.subarray(0, source.start), original.subarray(source.end)]);
+  const changed = next.equals(original) ? [] : [args.src];
+  if (!writeSuppressed && changed.length > 0) {
+    await writeAtomic(srcPath, next, {
+      expected: { kind: "file", label: args.src, snapshot }
+    });
+  }
+  return {
+    changed,
+    affected: [args.src],
+    written: !writeSuppressed && changed.length > 0,
+    noop: changed.length === 0,
+    status: changed.length === 0 ? "noop" : "applied",
+    moves: [
+      {
+        id: "move-1",
+        src: args.src,
+        dst: devNull,
+        payload_sha256: payloadSha256,
+        payload_bytes: payload.length,
+        source_range: source,
+        target_range: null,
+        insert_index: null
+      }
+    ],
+    patch: renderedPatch
+  };
+}
+function findSource(file, args) {
+  const result = findDelimitedRanges(file, args.srcStart, args.srcEnd);
+  const ranges = result.ranges;
+  if (ranges.length === 0) {
+    fail("source_not_found", `Source delimiters were not found in ${args.src}`, {
+      path: args.src,
+      phase: "source",
+      anchor: "src_start/src_end",
+      matches: 0
+    });
   }
-  if (envelopes.length > 1) {
-    fail("source_ambiguous", `Source anchors are ambiguous in ${patch.path}; matched ${envelopes.length} locations`);
+  if (ranges.length > 1 || result.truncated) {
+    fail("source_ambiguous", `Source delimiters are ambiguous in ${args.src}; ${matchedLocations(ranges.length, result.truncated)}`, {
+      path: args.src,
+      phase: "source",
+      anchor: "src_start/src_end",
+      ...matchCountDetails(ranges.length, result.truncated),
+      ranges: boundedRanges(ranges),
+      line_ranges: boundedLineRanges(file, ranges)
+    });
   }
-  fail("source_not_found", `Source anchors were not found in ${patch.path}`);
+  return ranges[0];
 }
-function findSourceEnvelopes(file, patch) {
-  const beforeMatches = indexesOf(file, patch.sourceBefore);
-  const afterMatches = indexesOf(file, patch.sourceAfter);
+function findDelimitedRanges(file, startNeedle, endNeedle, limit = 11) {
+  if (startNeedle.length === 0) {
+    return { ranges: [], truncated: false };
+  }
+  const maxMatches = normalizedLimit2(limit);
   const ranges = [];
-  for (const beforeStart of beforeMatches) {
-    const payloadStart = beforeStart + patch.sourceBefore.length;
-    const afterStart = afterMatches.find((candidate) => candidate >= payloadStart);
-    if (afterStart !== undefined) {
-      ranges.push({ start: payloadStart, end: afterStart });
+  let start = file.indexOf(startNeedle);
+  while (start !== -1) {
+    const searchFrom = start + startNeedle.length;
+    const endStart = file.indexOf(endNeedle, searchFrom);
+    if (endStart !== -1) {
+      if (ranges.length >= maxMatches) {
+        return { ranges, truncated: true };
+      }
+      ranges.push({ start, end: endStart + endNeedle.length });
     }
+    start = file.indexOf(startNeedle, start + 1);
   }
-  return ranges;
+  return { ranges, truncated: false };
 }
-function findTarget(file, patch) {
-  const matches = indexesOf(file, patch.target.anchor);
-  if (matches.length === 0) {
-    fail("target_not_found", `Target anchor was not found in ${patch.path}`);
+function normalizedLimit2(limit) {
+  if (!Number.isFinite(limit)) {
+    return Number.POSITIVE_INFINITY;
   }
-  if (matches.length > 1) {
-    fail("target_ambiguous", `Target anchor is ambiguous in ${patch.path}; matched ${matches.length} locations`);
+  return Math.max(0, Math.trunc(limit));
+}
+function targetAnchorName(args) {
+  if (args.targetBefore.length > 0 && args.targetAfter.length > 0) {
+    return "target_before+target_after";
   }
-  const start = matches[0];
-  const end = start + patch.target.anchor.length;
-  return {
-    range: { start, end },
-    insertIndex: patch.target.kind === "before" ? start : end
-  };
+  return args.targetBefore.length > 0 ? "target_before" : "target_after";
 }
-function indexesOf(haystack, needle) {
-  if (needle.length === 0) {
-    return [];
+function samePatchPath2(left, right) {
+  return posix2.normalize(left) === posix2.normalize(right);
+}
+async function selfCheckRenderedPatch(patch, files) {
+  if (patch === undefined) {
+    return;
   }
-  const indexes = [];
-  let index = haystack.indexOf(needle);
-  while (index !== -1) {
-    indexes.push(index);
-    index = haystack.indexOf(needle, index + 1);
+  checkPatchBytesInMemory(Buffer.from(patch, "utf8"), files);
+}
+function pairedSelfCheckFiles(srcLabel, dstLabel, srcOriginal, dstOriginal, sameFile) {
+  const identity = sameFile ? "move-file" : undefined;
+  const files = [{ path: srcLabel, bytes: srcOriginal, identity }];
+  if (dstLabel !== srcLabel) {
+    files.push({ path: dstLabel, bytes: dstOriginal, identity });
   }
-  return indexes;
+  return files;
 }
-function rangesOverlap(left, right) {
-  return left.start < right.end && right.start < left.end;
+function renderMovePatch(args, srcOriginal, dstOriginal, selection, sameFile, payloadSha256) {
+  const id = "move-1";
+  const { source, target, payload } = selection;
+  const sourceBefore = adjacentLineBefore(srcOriginal, source.start);
+  const sourceAfter = adjacentLineAfter(srcOriginal, source.end);
+  const targetBefore = args.targetBefore.length === 0 ? adjacentLineBefore(dstOriginal, target.range.start) : args.targetBefore;
+  const targetAfter = args.targetAfter.length === 0 ? adjacentLineAfter(dstOriginal, target.range.end) : args.targetAfter;
+  const payloadLines = countLines(payload);
+  const sourceHunkStart = source.start - sourceBefore.length;
+  const sourceOldStart = lineNumberAt2(srcOriginal, sourceHunkStart);
+  const sourceOldCount = countLines(sourceBefore) + payloadLines + countLines(sourceAfter);
+  const sourceNewStart = sameFile && target.insertIndex <= sourceHunkStart ? sourceOldStart + payloadLines : sourceOldStart;
+  const sourceNewCount = sourceOldCount - payloadLines;
+  const targetHunkStart = target.insertIndex - targetBefore.length;
+  const targetOldStart = lineNumberAt2(dstOriginal, targetHunkStart);
+  const targetOldCount = countLines(targetBefore) + countLines(targetAfter);
+  const targetNewStart = sameFile && source.end <= targetHunkStart ? targetOldStart - payloadLines : targetOldStart;
+  const targetNewCount = targetOldCount + payloadLines;
+  const sourceBody = joinPatchChunks([
+    renderHunkBytes(sourceBefore, " "),
+    renderHunkBytes(payload, "-"),
+    renderHunkBytes(sourceAfter, " ")
+  ]);
+  const targetBody = joinPatchChunks([
+    renderHunkBytes(targetBefore, " "),
+    renderHunkBytes(payload, "+"),
+    renderHunkBytes(targetAfter, " ")
+  ]);
+  const sourceHunkHeader = `@@ -${sourceOldStart},${sourceOldCount} +${sourceNewStart},${sourceNewCount} @@ blockpatch-source id=${id}`;
+  const targetHunkHeader = `@@ -${targetOldStart},${targetOldCount} +${targetNewStart},${targetNewCount} @@ blockpatch-target id=${id}`;
+  if (!sameFile) {
+    return [
+      `diff --blockpatch a/${args.src} b/${args.src}`,
+      "blockpatch version 1",
+      `blockpatch move id=${id} role=source payload-sha256=${payloadSha256}`,
+      `--- a/${args.src}`,
+      `+++ b/${args.src}`,
+      "",
+      sourceHunkHeader,
+      sourceBody,
+      "",
+      `diff --blockpatch a/${args.dst} b/${args.dst}`,
+      "blockpatch version 1",
+      `blockpatch move id=${id} role=target payload-sha256=${payloadSha256}`,
+      `--- a/${args.dst}`,
+      `+++ b/${args.dst}`,
+      "",
+      targetHunkHeader,
+      targetBody
+    ].join(`
+`) + `
+`;
+  }
+  return [
+    `diff --blockpatch a/${args.src} b/${args.dst}`,
+    "blockpatch version 1",
+    `blockpatch move id=${id} payload-sha256=${payloadSha256}`,
+    `--- a/${args.src}`,
+    `+++ b/${args.dst}`,
+    "",
+    sourceHunkHeader,
+    sourceBody,
+    targetHunkHeader,
+    targetBody
+  ].join(`
+`) + `
+`;
+}
+function renderInsertionPatch(args, dstOriginal, target, payloadSha256) {
+  const id = "move-1";
+  const targetBefore = args.targetBefore.length === 0 ? adjacentLineBefore(dstOriginal, target.range.start) : args.targetBefore;
+  const targetAfter = args.targetAfter.length === 0 ? adjacentLineAfter(dstOriginal, target.range.end) : args.targetAfter;
+  const payloadLines = countLines(args.payload);
+  const targetHunkStart = target.insertIndex - targetBefore.length;
+  const targetOldStart = lineNumberAt2(dstOriginal, targetHunkStart);
+  const targetOldCount = countLines(targetBefore) + countLines(targetAfter);
+  const targetNewCount = targetOldCount + payloadLines;
+  const targetBody = joinPatchChunks([
+    renderHunkBytes(targetBefore, " "),
+    renderHunkBytes(args.payload, "+"),
+    renderHunkBytes(targetAfter, " ")
+  ]);
+  return [
+    `diff --blockpatch a/${args.dst} b/${args.dst}`,
+    "blockpatch version 1",
+    `blockpatch move id=${id} payload-sha256=${payloadSha256}`,
+    `--- a/${args.dst}`,
+    `+++ b/${args.dst}`,
+    "",
+    `@@ -${targetOldStart},${targetOldCount} +${targetOldStart},${targetNewCount} @@ blockpatch-target id=${id}`,
+    targetBody
+  ].join(`
+`) + `
+`;
+}
+function renderDeletionPatch(args, srcOriginal, source, payload, payloadSha256) {
+  const id = "move-1";
+  const sourceBefore = adjacentLineBefore(srcOriginal, source.start);
+  const sourceAfter = adjacentLineAfter(srcOriginal, source.end);
+  const payloadLines = countLines(payload);
+  const sourceHunkStart = source.start - sourceBefore.length;
+  const sourceOldStart = lineNumberAt2(srcOriginal, sourceHunkStart);
+  const sourceOldCount = countLines(sourceBefore) + payloadLines + countLines(sourceAfter);
+  const sourceNewCount = sourceOldCount - payloadLines;
+  const sourceBody = joinPatchChunks([
+    renderHunkBytes(sourceBefore, " "),
+    renderHunkBytes(payload, "-"),
+    renderHunkBytes(sourceAfter, " ")
+  ]);
+  return [
+    `diff --blockpatch a/${args.src} b/${args.src}`,
+    "blockpatch version 1",
+    `blockpatch move id=${id} payload-sha256=${payloadSha256}`,
+    `--- a/${args.src}`,
+    `+++ b/${args.src}`,
+    "",
+    `@@ -${sourceOldStart},${sourceOldCount} +${sourceOldStart},${sourceNewCount} @@ blockpatch-source id=${id}`,
+    sourceBody
+  ].join(`
+`) + `
+`;
+}
+function renderFileCreationPatch(args, payloadSha256) {
+  const id = "move-1";
+  const payloadLines = countLines(args.payload);
+  const targetBody = renderHunkBytes(args.payload, "+");
+  return [
+    `diff --blockpatch ${devNull} b/${args.dst}`,
+    "blockpatch version 1",
+    `blockpatch move id=${id} payload-sha256=${payloadSha256}`,
+    `--- ${devNull}`,
+    `+++ b/${args.dst}`,
+    "",
+    `@@ -0,0 +${payloadLines === 0 ? "0,0" : `1,${payloadLines}`} @@ blockpatch-target id=${id}`,
+    targetBody
+  ].join(`
+`) + `
+`;
+}
+function renderFileRemovalPatch(args, payload, payloadSha256) {
+  const id = "move-1";
+  const payloadLines = countLines(payload);
+  const sourceBody = renderHunkBytes(payload, "-");
+  return [
+    `diff --blockpatch a/${args.src} ${devNull}`,
+    "blockpatch version 1",
+    `blockpatch move id=${id} payload-sha256=${payloadSha256}`,
+    `--- a/${args.src}`,
+    `+++ ${devNull}`,
+    "",
+    `@@ -${payloadLines === 0 ? "0,0" : `1,${payloadLines}`} +0,0 @@ blockpatch-source id=${id}`,
+    sourceBody
+  ].join(`
+`) + `
+`;
+}
+function lineNumberAt2(file, byteIndex) {
+  let line = 1;
+  for (let index = 0;index < byteIndex; index += 1) {
+    if (file[index] === 10) {
+      line += 1;
+    }
+  }
+  return line;
+}
+function countLines(bytes) {
+  if (bytes.length === 0) {
+    return 0;
+  }
+  let newlines = 0;
+  for (const byte of bytes) {
+    if (byte === 10) {
+      newlines += 1;
+    }
+  }
+  return bytes[bytes.length - 1] === 10 ? newlines : newlines + 1;
+}
+function joinPatchChunks(chunks) {
+  return chunks.filter((chunk) => chunk.length > 0).join(`
+`);
+}
+function adjacentLineBefore(file, index) {
+  if (index === 0) {
+    return Buffer.alloc(0);
+  }
+  const previousLf = file.lastIndexOf(10, index - 2);
+  return Buffer.from(file.subarray(previousLf === -1 ? 0 : previousLf + 1, index));
+}
+function adjacentLineAfter(file, index) {
+  if (index >= file.length) {
+    return Buffer.alloc(0);
+  }
+  const nextLf = file.indexOf(10, index);
+  return Buffer.from(file.subarray(index, nextLf === -1 ? file.length : nextLf + 1));
+}
+function renderHunkBytes(bytes, prefix) {
+  const text2 = decodeUtf8(bytes);
+  if (text2.length === 0) {
+    return "";
+  }
+  const lines = text2.split(/(?<=\n)/);
+  return lines.filter((line) => line.length > 0).map((line) => {
+    if (line.endsWith(`
+`)) {
+      return `${prefix}${line.slice(0, -1)}`;
+    }
+    return `${prefix}${line}
+\`;
+  }).join(`
+`);
 }
-async function writeAtomic(path, bytes) {
-  const info = await stat(path);
-  const dir = dirname(path);
-  const base = basename(path);
-  const temp = join(dir, `.${base}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+function decodeUtf8(bytes) {
   try {
-    await writeFile(temp, bytes, { flag: "wx" });
-    await chmod(temp, info.mode);
-    await rename(temp, path);
-  } catch (error) {
-    await unlink(temp).catch(() => {
-      return;
+    return utf8Decoder.decode(bytes);
+  } catch {
+    fail("invalid_utf8", "move --diff cannot render invalid UTF-8 bytes", {
+      phase: "render",
+      anchor: "move --diff"
     });
-    throw error;
   }
 }
 
 // src/cli.ts
+var packageJson = createRequire(import.meta.url)("../package.json");
+var OUTPUT_FLAGS = new Set(["--json-output", "--explain"]);
+var CWD_VALUE_FLAGS = new Set(["--cwd", "--directory", "-d"]);
+var PATCH_INPUT_VALUE_FLAGS = new Set(["-i", "--input"]);
+var STRIP_VALUE_FLAGS = new Set(["-p", "--strip"]);
+var PATCH_VALUE_FLAGS = new Set([...CWD_VALUE_FLAGS, ...PATCH_INPUT_VALUE_FLAGS, ...STRIP_VALUE_FLAGS]);
+var MOVE_JSON_VALUE_FLAGS = new Set(["--json"]);
+var MOVE_KEY_BY_FLAG = {
+  "--src": "src",
+  "--src-start": "src_start",
+  "--src-end": "src_end",
+  "--dst": "dst",
+  "--payload": "payload",
+  "--target-before": "target_before",
+  "--target-after": "target_after",
+  "--expected-payload-sha256": "expected_payload_sha256"
+};
+var MOVE_ARG_VALUE_FLAGS = new Set(Object.keys(MOVE_KEY_BY_FLAG));
+var MOVE_VALUE_FLAGS = new Set([...CWD_VALUE_FLAGS, ...MOVE_JSON_VALUE_FLAGS, ...MOVE_ARG_VALUE_FLAGS]);
 async function main(argv) {
   const options = parseArgs(argv);
   if (options.command === "help") {
@@ -267,84 +2614,401 @@ async function main(argv) {
     return 0;
   }
   if (options.command === "version") {
-    console.log("blockpatch 0.1.0");
+    writeSuccess(options, { version: packageJson.version });
+    return 0;
+  }
+  if (options.command === "move" || options.command === "plan") {
+    const args = await loadMoveArgs(options);
+    const result2 = await moveBlock(args, {
+      cwd: options.cwd,
+      dryRun: options.dryRun ? true : undefined,
+      diff: options.diff
+    });
+    if (options.diff && result2.patch !== undefined) {
+      writeSuccess(options, result2, result2.patch);
+      return 0;
+    }
+    writeChangeResult(options, result2, options.dryRun || args.dry_run === true ? "would change" : "changed");
     return 0;
   }
-  if (options.patchPath === undefined) {
-    throw new BlockPatchError("missing_patch", "Missing patch file path");
+  const result = await runPatchCommand(options);
+  const verb = options.command === "check" || options.dryRun ? "would change" : "changed";
+  writeChangeResult(options, result, verb);
+  return 0;
+}
+async function runPatchCommand(options) {
+  const patchPath = options.patchPath ?? "-";
+  const inputPatchPath = patchPath === "-" ? patchPath : resolve3(patchPath);
+  if (options.command === "check") {
+    return patchPath === "-" ? checkPatchBytes(await readStdin(), {
+      cwd: options.cwd,
+      reverse: options.reverse,
+      stripComponents: options.stripComponents
+    }) : checkPatchFile(inputPatchPath, {
+      cwd: options.cwd,
+      reverse: options.reverse,
+      stripComponents: options.stripComponents
+    });
   }
-  const result = options.command === "check" ? await checkPatchFile(options.patchPath, { cwd: options.cwd }) : await applyPatchFile(options.patchPath, {
+  return patchPath === "-" ? applyPatchBytes(await readStdin(), {
+    cwd: options.cwd,
+    dryRun: options.dryRun,
+    reverse: options.reverse,
+    stripComponents: options.stripComponents
+  }) : applyPatchFile(inputPatchPath, {
     cwd: options.cwd,
-    dryRun: options.dryRun
+    dryRun: options.dryRun,
+    reverse: options.reverse,
+    stripComponents: options.stripComponents
   });
-  const verb = options.command === "check" || options.dryRun ? "would change" : "changed";
-  for (const path of result.changed) {
-    console.log(`${verb} ${path}`);
+}
+async function loadMoveArgs(options) {
+  if (options.moveArgs !== undefined) {
+    return options.moveArgs;
+  }
+  if (options.moveJsonPath === undefined) {
+    throw new BlockPatchError("missing_move_args", `${options.command} requires --json or --src flags`);
+  }
+  const jsonBytes = options.moveJsonPath === "-" ? await readStdin() : await readFileChecked(resolve3(options.moveJsonPath), "move JSON file");
+  try {
+    return JSON.parse(jsonBytes.toString("utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new BlockPatchError("invalid_json", `Invalid move JSON: ${message}`);
   }
-  return 0;
 }
 function parseArgs(argv) {
   const args = [...argv];
+  const outputFlags = takeLeadingOutputFlags(args);
   const first = args.shift();
   if (first === undefined || first === "help" || first === "--help" || first === "-h") {
-    return { command: "help", cwd: process.cwd(), dryRun: false };
+    return base("help", outputFlags.jsonOutput);
   }
   if (first === "version" || first === "--version" || first === "-v") {
-    return { command: "version", cwd: process.cwd(), dryRun: false };
+    const options = base("version", outputFlags.jsonOutput);
+    for (const arg of args) {
+      if (isOutputFlag(arg)) {
+        options.jsonOutput = true;
+        continue;
+      }
+      if (arg.startsWith("-")) {
+        throw new BlockPatchError("unknown_option", `Unknown option: ${arg}`);
+      }
+      throw new BlockPatchError("too_many_args", `Unexpected argument: ${arg}`);
+    }
+    return options;
   }
-  if (first !== "apply" && first !== "check") {
+  if (first !== "apply" && first !== "check" && first !== "move" && first !== "plan") {
     throw new BlockPatchError("unknown_command", `Unknown command: ${first}`);
   }
-  let cwd = process.cwd();
-  let dryRun = false;
-  let patchPath;
+  if (first === "move" || first === "plan") {
+    return parseMoveArgs(first, args, first === "plan" ? true : outputFlags.jsonOutput, outputFlags.explain);
+  }
+  return parsePatchArgs(first, args, outputFlags.jsonOutput, outputFlags.explain);
+}
+function parsePatchArgs(command, args, jsonOutput, explain) {
+  const options = base(command, jsonOutput);
+  if (explain && command === "apply") {
+    options.dryRun = true;
+  }
   while (args.length > 0) {
     const arg = args.shift();
+    if (takeOutputFlag(options, arg)) {
+      continue;
+    }
     if (arg === "--dry-run") {
-      dryRun = true;
+      options.dryRun = true;
       continue;
     }
-    if (arg === "--cwd") {
-      const value = args.shift();
-      if (value === undefined) {
-        throw new BlockPatchError("missing_cwd", "Missing value for --cwd");
-      }
-      cwd = resolve2(value);
+    if (arg === "--reverse" || arg === "-R") {
+      options.reverse = true;
+      continue;
+    }
+    if (isValueFlag(arg, CWD_VALUE_FLAGS)) {
+      options.cwd = requireValue(args, arg, true);
       continue;
     }
     if (arg?.startsWith("--cwd=")) {
-      cwd = resolve2(arg.slice("--cwd=".length));
+      options.cwd = resolve3(arg.slice("--cwd=".length));
+      continue;
+    }
+    if (arg?.startsWith("--directory=")) {
+      options.cwd = resolve3(arg.slice("--directory=".length));
+      continue;
+    }
+    if (isValueFlag(arg, PATCH_INPUT_VALUE_FLAGS)) {
+      setPatchPath(options, requireValue(args, arg, false));
+      continue;
+    }
+    if (arg?.startsWith("--input=")) {
+      setPatchPath(options, arg.slice("--input=".length));
+      continue;
+    }
+    const stripComponents = parseStripOption(arg, args);
+    if (stripComponents !== undefined) {
+      options.stripComponents = stripComponents;
       continue;
     }
-    if (arg?.startsWith("-")) {
+    if (arg?.startsWith("-") && arg !== "-") {
       throw new BlockPatchError("unknown_option", `Unknown option: ${arg}`);
     }
-    if (patchPath !== undefined) {
-      throw new BlockPatchError("too_many_args", `Unexpected argument: ${arg}`);
+    setPatchPath(options, arg ?? "");
+  }
+  if (command === "check" && options.dryRun) {
+    throw new BlockPatchError("invalid_option", "--dry-run is only valid with apply or move");
+  }
+  return options;
+}
+function parseMoveArgs(command, args, jsonOutput, explain) {
+  const options = base(command, jsonOutput);
+  if (command === "plan") {
+    options.dryRun = true;
+    options.diff = true;
+    options.jsonOutput = true;
+  }
+  if (explain) {
+    options.dryRun = true;
+  }
+  const moveArgs = {};
+  let sawFlagArgs = false;
+  while (args.length > 0) {
+    const arg = args.shift();
+    if (takeOutputFlag(options, arg)) {
+      continue;
+    }
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+    if (arg === "--diff") {
+      options.diff = true;
+      continue;
+    }
+    if (isValueFlag(arg, CWD_VALUE_FLAGS)) {
+      options.cwd = requireValue(args, arg, true);
+      continue;
+    }
+    if (arg?.startsWith("--cwd=")) {
+      options.cwd = resolve3(arg.slice("--cwd=".length));
+      continue;
+    }
+    if (arg?.startsWith("--directory=")) {
+      options.cwd = resolve3(arg.slice("--directory=".length));
+      continue;
+    }
+    if (isValueFlag(arg, MOVE_JSON_VALUE_FLAGS)) {
+      options.moveJsonPath = requireValue(args, arg, false);
+      continue;
     }
-    patchPath = arg;
+    if (arg?.startsWith("--json=")) {
+      options.moveJsonPath = arg.slice("--json=".length);
+      continue;
+    }
+    const key = argToMoveKey(arg);
+    if (key !== undefined) {
+      moveArgs[key] = requireValue(args, arg ?? "", false);
+      sawFlagArgs = true;
+      continue;
+    }
+    throw new BlockPatchError("unknown_option", `Unknown option: ${String(arg)}`);
+  }
+  if (options.moveJsonPath !== undefined && sawFlagArgs) {
+    throw new BlockPatchError("invalid_option", "move cannot combine --json with --src flags");
+  }
+  if (sawFlagArgs) {
+    options.moveArgs = moveArgs;
+  }
+  return options;
+}
+function argToMoveKey(arg) {
+  return MOVE_KEY_BY_FLAG[arg];
+}
+function base(command, jsonOutput) {
+  return {
+    command,
+    cwd: process.cwd(),
+    dryRun: false,
+    diff: false,
+    jsonOutput,
+    reverse: false,
+    stripComponents: 1
+  };
+}
+function setPatchPath(options, path) {
+  if (options.patchPath !== undefined) {
+    throw new BlockPatchError("too_many_args", `Unexpected argument: ${path}`);
+  }
+  options.patchPath = path;
+}
+function parseStripOption(arg, args) {
+  if (isValueFlag(arg, STRIP_VALUE_FLAGS)) {
+    return parseStripComponents(requireValue(args, arg, false), arg);
+  }
+  if (arg?.startsWith("-p") === true && arg.length > 2) {
+    return parseStripComponents(arg.slice(2), "-p");
+  }
+  if (arg?.startsWith("--strip=") === true) {
+    return parseStripComponents(arg.slice("--strip=".length), "--strip");
+  }
+  return;
+}
+function parseStripComponents(value, option) {
+  if (!/^\d+$/.test(value)) {
+    throw new BlockPatchError("invalid_option", `Invalid strip count for ${option}: ${value}`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    throw new BlockPatchError("invalid_option", `Invalid strip count for ${option}: ${value}`);
+  }
+  return parsed;
+}
+function takeLeadingOutputFlags(args) {
+  let jsonOutput = false;
+  let explain = false;
+  while (isOutputFlag(args[0])) {
+    const arg = args.shift();
+    jsonOutput = true;
+    explain = explain || arg === "--explain";
+  }
+  return { jsonOutput, explain };
+}
+function takeOutputFlag(options, arg) {
+  if (arg === "--explain") {
+    options.jsonOutput = true;
+    if (options.command === "apply" || options.command === "move" || options.command === "plan") {
+      options.dryRun = true;
+    }
+    return true;
+  }
+  if (arg === "--json-output") {
+    options.jsonOutput = true;
+    return true;
+  }
+  return false;
+}
+function isOutputFlag(arg) {
+  return arg !== undefined && OUTPUT_FLAGS.has(arg);
+}
+function isValueFlag(arg, flags) {
+  return arg !== undefined && flags.has(arg);
+}
+function requireValue(args, option, pathValue) {
+  const value = args.shift();
+  if (value === undefined) {
+    throw new BlockPatchError("missing_option_value", `Missing value for ${option}`);
+  }
+  return pathValue ? resolve3(value) : value;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+function writeChangeResult(options, result, verb) {
+  if (options.jsonOutput) {
+    writeSuccess(options, result);
+    return;
+  }
+  for (const path of result.changed) {
+    console.log(`${verb} ${path}`);
+  }
+  if (result.changed.length === 0) {
+    for (const path of result.affected) {
+      console.log(`unchanged ${path}`);
+    }
+  }
+}
+function writeSuccess(options, result, plainText) {
+  if (options.jsonOutput) {
+    console.log(JSON.stringify({ ok: true, ...objectResult(result), ...jsonSuccessMetadata(options) }));
+    return;
   }
-  if (first === "check" && dryRun) {
-    throw new BlockPatchError("invalid_option", "--dry-run is only valid with apply");
+  if (plainText !== undefined) {
+    console.log(plainText);
+    return;
+  }
+  if (typeof result === "object" && result !== null && "version" in result) {
+    console.log(`blockpatch ${result.version}`);
+  }
+}
+function objectResult(result) {
+  return typeof result === "object" && result !== null ? result : {};
+}
+function jsonSuccessMetadata(options) {
+  if (options.command === "apply" || options.command === "check") {
+    return { strip_components: options.stripComponents };
   }
-  return { command: first, patchPath, cwd, dryRun };
+  return {};
 }
 function printHelp() {
   console.log(`blockpatch
 
 Usage:
-  blockpatch check <patch.blockpatch> [--cwd <dir>]
-  blockpatch apply <patch.blockpatch> [--cwd <dir>] [--dry-run]
+  blockpatch check [patch.blockpatch|-] [-d <dir>] [-pN] [-R|--reverse] [--json-output|--explain]
+  blockpatch apply [patch.blockpatch|-] [-i <patch.blockpatch>] [-d <dir>] [-pN] [-R|--reverse] [--dry-run] [--json-output|--explain]
+  blockpatch plan --json <path.json|-> [--cwd <dir>]
+  blockpatch move --json <path.json|-> [--cwd <dir>] [--dry-run] [--diff] [--json-output|--explain]
+  blockpatch move --src <path> --src-start <text> --src-end <text> --dst <path> --target-before <text> --target-after <text> [--expected-payload-sha256 <sha256>]
+  blockpatch move --src /dev/null --dst <path> --payload <text> --target-before <text>
+  blockpatch move --src <path> --src-start <text> --src-end <text> --dst /dev/null
   blockpatch version
 `);
 }
 main(process.argv.slice(2)).then((code) => {
   process.exitCode = code;
 }, (error) => {
+  const jsonOutput = hasJsonOutputFlag(process.argv.slice(2));
   if (error instanceof BlockPatchError) {
-    console.error(`blockpatch: ${error.message}`);
+    writeError(error.code, error.message, jsonOutput, error.details);
     process.exitCode = 1;
     return;
   }
-  throw error;
+  const message = error instanceof Error ? error.message : String(error);
+  writeError("unexpected_error", message, jsonOutput);
+  process.exitCode = 1;
 });
+function hasJsonOutputFlag(argv) {
+  const args = [...argv];
+  const outputFlags = takeLeadingOutputFlags(args);
+  if (outputFlags.jsonOutput) {
+    return true;
+  }
+  const command = args.shift();
+  if (command === "apply" || command === "check") {
+    return hasPatchJsonOutputFlag(args);
+  }
+  if (command === "move") {
+    return hasMoveJsonOutputFlag(args);
+  }
+  if (command === "plan") {
+    return true;
+  }
+  return args.some(isOutputFlag);
+}
+function hasPatchJsonOutputFlag(args) {
+  return hasJsonOutputAfterValueFlags(args, PATCH_VALUE_FLAGS);
+}
+function hasMoveJsonOutputFlag(args) {
+  return hasJsonOutputAfterValueFlags(args, MOVE_VALUE_FLAGS);
+}
+function hasJsonOutputAfterValueFlags(args, valueFlags) {
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (isOutputFlag(arg)) {
+      return true;
+    }
+    if (isValueFlag(arg, valueFlags)) {
+      index += 1;
+    }
+  }
+  return false;
+}
+function writeError(code, message, jsonOutput, details = {}) {
+  if (jsonOutput) {
+    console.error(JSON.stringify({ ok: false, error: { code, message, ...details } }));
+    return;
+  }
+  console.error(`blockpatch: ${message}`);
+}