@smthrs/std 0.0.0-stage → 1.0.0-rc.12

package/dist/cjs/ApplyPatch.js

@@ -0,0 +1,309 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ApplyPatch_exports = {};
+__export(ApplyPatch_exports, {
+  Input: () => Input,
+  Output: () => Output,
+  activity: () => activity,
+  capabilities: () => capabilities,
+  description: () => description,
+  effects: () => effects,
+  effectsFor: () => effectsFor,
+  flow: () => flow,
+  name: () => name,
+  paths: () => paths,
+  presentation: () => presentation,
+  run: () => run
+});
+module.exports = __toCommonJS(ApplyPatch_exports);
+var Path = __toESM(require("@smthrs/kernel/Path"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var ApplyPatchText = __toESM(require("./internal/ApplyPatch.js"), 1);
+var import_Declaration = require("./internal/Declaration.js");
+var Diagnostics = __toESM(require("./internal/Diagnostics.js"), 1);
+var FileMutation = __toESM(require("./internal/FileMutation.js"), 1);
+var FsFailure = __toESM(require("./internal/FsFailure.js"), 1);
+var Preserve = __toESM(require("./internal/Preserve.js"), 1);
+var StdError = __toESM(require("./StdError.js"), 1);
+const name = "apply_patch";
+const description = "The `apply_patch` tool can be used to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.";
+const Input = Schema.Struct({
+  input: Schema.String.annotate({ description: "The entire contents of the apply_patch command" })
+});
+const Output = Schema.Struct({
+  output: Schema.String.annotate({
+    description: "Codex-style summary: 'Success. Updated the following files:' with A/M/D lines"
+  }),
+  added: Schema.Array(Schema.String).annotate({ description: "Paths of files created by the patch" }),
+  modified: Schema.Array(Schema.String).annotate({ description: "Paths of files updated by the patch" }),
+  deleted: Schema.Array(Schema.String).annotate({ description: "Paths of files deleted by the patch" })
+});
+const effects = (0, import_Declaration.envelope)({ tier: "compensable", mode: "hermetic", reads: ["/**"], writes: ["/**"] });
+const effectsFor = (_input) => effects;
+const capabilities = [(0, import_Declaration.capability)("fs:read", "/**"), (0, import_Declaration.capability)("fs:write", "/**")];
+const flow = { name, description, input: Input, output: Output, capabilities, effects };
+const activity = "writes";
+const presentation = {
+  verb: { pending: "patching", success: "patched", failure: "failed to patch" },
+  subject: "patch",
+  result: "patch"
+};
+const paths = (patch) => {
+  let parsed;
+  try {
+    parsed = ApplyPatchText.parsePatch(patch);
+  } catch {
+    return void 0;
+  }
+  return [
+    ...new Set(
+      parsed.hunks.flatMap(
+        (hunk) => hunk.kind === "update" && hunk.movePath !== void 0 ? [hunk.path, hunk.movePath] : [hunk.path]
+      )
+    )
+  ];
+};
+const unknownFailureSentence = "Something went wrong on our side. Not your fault.";
+const unknownFailure = (error, path) => Effect.logError("apply_patch failed unexpectedly", error).pipe(
+  Effect.andThen(Effect.fail(
+    new StdError.StdError(
+      path === void 0 ? { code: "command_failed", message: unknownFailureSentence } : { code: "command_failed", message: unknownFailureSentence, path }
+    )
+  ))
+);
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+const run = Effect.fn("ApplyPatch.run")(function* (input) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  let parsed;
+  try {
+    parsed = ApplyPatchText.parsePatch(input.input);
+  } catch (error) {
+    if (error instanceof ApplyPatchText.ParseError) {
+      return yield* Effect.fail(new StdError.StdError({ code: "invalid_input", message: error.message }));
+    }
+    return yield* unknownFailure(error);
+  }
+  const identity = (value) => {
+    const resolved = path.resolve(value);
+    return fileSystem.realPath(resolved).pipe(
+      Effect.catch(
+        (error) => error.reason._tag === "NotFound" ? fileSystem.realPath(path.dirname(resolved)).pipe(
+          Effect.map((parent) => path.resolve(parent, path.basename(resolved))),
+          Effect.catch(
+            (parentError) => parentError.reason._tag === "NotFound" ? Effect.succeed(resolved) : Effect.fail(parentError)
+          )
+        ) : Effect.fail(error)
+      ),
+      Effect.mapError(FsFailure.denied(value, () => new StdError.StdError({
+        code: "command_failed",
+        message: `Failed to resolve patch path ${value}`,
+        path: value
+      })))
+    );
+  };
+  const touched = /* @__PURE__ */ new Set();
+  for (const hunk of parsed.hunks) {
+    const source = yield* identity(hunk.path);
+    const destination = hunk.kind === "update" && hunk.movePath !== void 0 ? yield* identity(hunk.movePath) : void 0;
+    const claims = [[hunk.path, source]];
+    if (hunk.kind === "update" && hunk.movePath !== void 0 && destination !== source) {
+      claims.push([hunk.movePath, destination]);
+    }
+    for (const [claimed, key] of claims) {
+      if (touched.has(key)) {
+        return yield* Effect.fail(
+          new StdError.StdError({
+            code: "invalid_input",
+            message: `The patch names ${claimed} in more than one section; give one section per path`,
+            path: claimed
+          })
+        );
+      }
+      touched.add(key);
+    }
+  }
+  yield* FileMutation.validate(
+    fileSystem,
+    parsed.hunks.flatMap(
+      (hunk) => hunk.kind === "update" && hunk.movePath !== void 0 ? [hunk.path, hunk.movePath] : [hunk.path]
+    )
+  );
+  for (const hunk of parsed.hunks) {
+    const destination = hunk.kind === "add" ? hunk.path : hunk.kind === "update" ? hunk.movePath : void 0;
+    if (destination !== void 0 && !FileMutation.isVersioned(fileSystem)) {
+      yield* fileSystem.makeDirectory(path.dirname(destination), { recursive: true }).pipe(
+        Effect.mapError(
+          FsFailure.denied(destination, () => new StdError.StdError({
+            code: "command_failed",
+            message: `Failed to create parent directories for ${destination}`,
+            path: destination
+          }))
+        )
+      );
+    }
+  }
+  return yield* Effect.scoped(Effect.gen(function* () {
+    const mutation = yield* FileMutation.acquire(
+      fileSystem,
+      parsed.hunks.flatMap(
+        (hunk) => hunk.kind === "update" && hunk.movePath !== void 0 ? [hunk.path, hunk.movePath] : [hunk.path]
+      ),
+      path
+    );
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    const prepared = /* @__PURE__ */ new Map();
+    for (const hunk of parsed.hunks) {
+      if (hunk.kind !== "update") continue;
+      const bytes = yield* mutation.read(
+        hunk.path,
+        fileSystem.readFile(hunk.path).pipe(
+          Effect.mapError(FsFailure.reading(hunk.path, `Failed to read file to update ${hunk.path}`))
+        )
+      );
+      if (bytes.includes(0)) {
+        return yield* Effect.fail(
+          new StdError.StdError({
+            code: "binary_file",
+            message: `Cannot read binary file: ${hunk.path}`,
+            path: hunk.path
+          })
+        );
+      }
+      const original = yield* Effect.try({
+        try: () => decoder.decode(bytes),
+        catch: () => new StdError.StdError({
+          code: "binary_file",
+          message: `File is not valid UTF-8: ${hunk.path}`,
+          path: hunk.path
+        })
+      });
+      let contents;
+      try {
+        contents = ApplyPatchText.deriveNewContents(original, hunk.path, hunk.chunks);
+      } catch (error) {
+        if (error instanceof ApplyPatchText.ComputeReplacementsError) {
+          return yield* Effect.fail(
+            new StdError.StdError({ code: "no_match", message: error.message, path: hunk.path })
+          );
+        }
+        return yield* unknownFailure(error, hunk.path);
+      }
+      prepared.set(hunk, contents);
+    }
+    const changes = [];
+    const moves = /* @__PURE__ */ new Set();
+    for (const hunk of parsed.hunks) {
+      if (hunk.kind === "delete") {
+        changes.push({ path: hunk.path, content: null });
+      } else if (hunk.kind === "add") {
+        changes.push({ path: hunk.path, content: encoder.encode(hunk.contents) });
+      } else {
+        changes.push({
+          path: hunk.movePath ?? hunk.path,
+          content: encoder.encode(prepared.get(hunk))
+        });
+        if (hunk.movePath !== void 0 && (yield* identity(hunk.movePath)) !== (yield* identity(hunk.path))) {
+          moves.add(hunk);
+          changes.push({ path: hunk.path, content: null });
+        }
+      }
+    }
+    const mutationFailure = (code, message, offendingPath) => (error) => error.reason._tag === "PermissionDenied" ? mutationError("permission_denied", `Permission denied: ${offendingPath}`, offendingPath) : mutationError(code, message, offendingPath);
+    const mutationError = (code, message, offendingPath) => new StdError.StdError({
+      code,
+      message: `${message}; applied before failure: added=${JSON.stringify(added)}, modified=${JSON.stringify(modified)}, deleted=${JSON.stringify(deleted)}`,
+      path: offendingPath
+    });
+    yield* mutation.commit(
+      changes,
+      Effect.gen(function* () {
+        for (const hunk of parsed.hunks) {
+          switch (hunk.kind) {
+            case "add": {
+              yield* fileSystem.writeFile(hunk.path, encoder.encode(hunk.contents)).pipe(
+                Effect.mapError(mutationFailure("command_failed", `Failed to write file ${hunk.path}`, hunk.path))
+              );
+              added.push(hunk.path);
+              break;
+            }
+            case "delete": {
+              yield* fileSystem.remove(hunk.path).pipe(
+                Effect.mapError(mutationFailure("not_found", `Failed to delete file ${hunk.path}`, hunk.path))
+              );
+              deleted.push(hunk.path);
+              break;
+            }
+            case "update": {
+              const contents = prepared.get(hunk);
+              const destination = hunk.movePath ?? hunk.path;
+              yield* Preserve.writeFile(fileSystem, destination, encoder.encode(contents)).pipe(
+                Effect.mapError(
+                  (error) => error.reason.method === "chmod" ? mutationError(
+                    "command_failed",
+                    `Could not preserve the mode of ${destination} before replacement by chmod`,
+                    destination
+                  ) : mutationFailure("command_failed", `Failed to write file ${destination}`, destination)(error)
+                )
+              );
+              modified.push(destination);
+              if (moves.has(hunk)) {
+                yield* fileSystem.remove(hunk.path).pipe(
+                  Effect.mapError(
+                    mutationFailure("command_failed", `Failed to remove original ${hunk.path}`, hunk.path)
+                  )
+                );
+              }
+              break;
+            }
+          }
+        }
+      })
+    );
+    for (const change of changes) {
+      if (change.content === null) yield* Diagnostics.close(path.resolve(change.path));
+      else yield* Diagnostics.sync(path.resolve(change.path), decoder.decode(change.content));
+    }
+    const summary = {
+      added: parsed.hunks.filter((hunk) => hunk.kind === "add").map((hunk) => hunk.path),
+      deleted: parsed.hunks.filter((hunk) => hunk.kind === "delete").map((hunk) => hunk.path),
+      modified: parsed.hunks.filter((hunk) => hunk.kind === "update").map((hunk) => hunk.movePath ?? hunk.path)
+    };
+    return {
+      output: ApplyPatchText.printSummary(summary),
+      ...summary
+    };
+  }));
+});
+//# sourceMappingURL=ApplyPatch.js.map

package/dist/cjs/ApplyPatch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ApplyPatch.ts"],
+  "sourcesContent": ["/**\n * apply_patch flow declaration and portable handler.\n *\n * A Codex CLI clone: the V4A patch grammar (`*** Begin Patch` /\n * `*** Add File:` / `*** Update File:` / `*** Delete File:` /\n * `*** End Patch`), the fuzzy context-matching applier, and Codex's error\n * and summary text, expressed as a flow over the kernel filesystem.\n *\n * @since 1.0.0\n */\n\nimport * as Path from \"@smthrs/kernel/Path\"\nimport * as Effect from \"effect/Effect\"\nimport * as FileSystem from \"effect/FileSystem\"\nimport type * as PlatformError from \"effect/PlatformError\"\nimport * as Schema from \"effect/Schema\"\nimport * as ApplyPatchText from \"./internal/ApplyPatch.ts\"\nimport { capability, envelope } from \"./internal/Declaration.ts\"\nimport * as Diagnostics from \"./internal/Diagnostics.ts\"\nimport * as FileMutation from \"./internal/FileMutation.ts\"\nimport * as FsFailure from \"./internal/FsFailure.ts\"\nimport * as Preserve from \"./internal/Preserve.ts\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * Registry name for the apply_patch flow. Matches the Codex CLI tool name.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const name = \"apply_patch\"\n\n/**\n * Model-facing description of the apply_patch flow. Matches the Codex CLI\n * freeform tool description.\n *\n * @category descriptions\n * @since 1.0.0\n */\nexport const description =\n  \"The `apply_patch` tool can be used to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.\"\n\n/**\n * Input schema for the apply_patch flow.\n *\n * Codex delivers the patch as freeform text; the JSON function fallback uses\n * a single `input` field, which is the shape cloned here.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Input = Schema.Struct({\n  input: Schema.String.annotate({ description: \"The entire contents of the apply_patch command\" })\n})\n\n/**\n * Decoded input accepted by the `apply_patch` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * Output schema for the apply_patch flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Schema.Struct({\n  output: Schema.String.annotate({\n    description: \"Codex-style summary: 'Success. Updated the following files:' with A/M/D lines\"\n  }),\n  added: Schema.Array(Schema.String).annotate({ description: \"Paths of files created by the patch\" }),\n  modified: Schema.Array(Schema.String).annotate({ description: \"Paths of files updated by the patch\" }),\n  deleted: Schema.Array(Schema.String).annotate({ description: \"Paths of files deleted by the patch\" })\n})\n\n/**\n * Decoded output returned by the `apply_patch` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Output = typeof Output.Type\n\n/**\n * Static conservative effect envelope for the apply_patch flow.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effects = envelope({ tier: \"compensable\", mode: \"hermetic\", reads: [\"/**\"], writes: [\"/**\"] })\n\n/**\n * Narrows the effect envelope for a decoded invocation.\n *\n * A patch names its files inside its own text rather than in a decoded field,\n * and the parse that finds them is the same parse that can fail, so there is\n * nothing here to narrow before the handler runs: the static envelope is the\n * honest answer.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effectsFor = (_input: typeof Input.Type) => effects\n\n/**\n * Capabilities required by the apply_patch flow.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities = [capability(\"fs:read\", \"/**\"), capability(\"fs:write\", \"/**\")]\n\n/**\n * Declaration-only apply_patch flow.\n *\n * @category flows\n * @since 1.0.0\n */\nexport const flow = { name, description, input: Input, output: Output, capabilities, effects } as const\n\n/**\n * What a call to this flow does, for a reader of a run.\n *\n * Display metadata only. `@smthrs/registry` `Descriptor.FlowActivity` is the\n * governing vocabulary and `StandardFlows` binds this value onto the flow's\n * descriptor, where the binding site checks it. `declarationDigest` excludes\n * it, so declaring it cannot invalidate a call identity or a cached prompt.\n *\n * @category presentation\n * @since 1.0.0-rc.0\n */\nexport const activity = \"writes\" as const\n\n/**\n * How one recorded call to this flow reads: the verb for each settlement, the\n * input field that is its subject, and the measured output fields a one-line\n * summary may count.\n *\n * Display metadata only, governed by `@smthrs/registry`\n * `Descriptor.CallPresentation` and checked where `StandardFlows` binds it.\n *\n * @category presentation\n * @since 1.0.0-rc.0\n */\nexport const presentation = {\n  verb: { pending: \"patching\", success: \"patched\", failure: \"failed to patch\" },\n  subject: \"patch\",\n  result: \"patch\"\n} as const\n\n/**\n * Every path a patch writes, in the order it names them, including a move's\n * destination. The patch is read by the parser {@link run} uses, so a header\n * `run` accepts is never missed.\n *\n * Returns `undefined` when `run` would refuse the patch. A caller asking\n * permission for the call then asks for everything the flow declares.\n *\n * @category parsing\n * @since 1.0.0-rc.1\n */\nexport const paths = (patch: string): ReadonlyArray<string> | undefined => {\n  let parsed: ApplyPatchText.ParsedPatch\n  try {\n    parsed = ApplyPatchText.parsePatch(patch)\n  } catch {\n    return undefined\n  }\n  return [\n    ...new Set(\n      parsed.hunks.flatMap((hunk) =>\n        hunk.kind === \"update\" && hunk.movePath !== undefined ? [hunk.path, hunk.movePath] : [hunk.path]\n      )\n    )\n  ]\n}\n\n/**\n * The one sentence a model sees for a failure this handler did not design.\n * The raw failure goes to the log, never into the tool result.\n */\nconst unknownFailureSentence = \"Something went wrong on our side. Not your fault.\"\n\nconst unknownFailure = (error: unknown, path?: string): Effect.Effect<never, StdError.StdError> =>\n  Effect.logError(\"apply_patch failed unexpectedly\", error).pipe(\n    Effect.andThen(Effect.fail(\n      new StdError.StdError(\n        path === undefined\n          ? { code: \"command_failed\", message: unknownFailureSentence }\n          : { code: \"command_failed\", message: unknownFailureSentence, path }\n      )\n    ))\n  )\n\nconst encoder = new TextEncoder()\nconst decoder = new TextDecoder(\"utf-8\", { fatal: true })\n\n/**\n * Parses and applies a V4A patch through the permission-aware kernel\n * filesystem, preserving Codex error text.\n *\n * @category handlers\n * @since 1.0.0\n */\nexport const run = Effect.fn(\"ApplyPatch.run\")(function*(\n  input: typeof Input.Type\n): Effect.fn.Return<typeof Output.Type, StdError.StdError, FileSystem.FileSystem | Path.Path> {\n  const fileSystem = yield* FileSystem.FileSystem\n  const path = yield* Path.Path\n\n  let parsed: ApplyPatchText.ParsedPatch\n  try {\n    parsed = ApplyPatchText.parsePatch(input.input)\n  } catch (error) {\n    if (error instanceof ApplyPatchText.ParseError) {\n      return yield* Effect.fail(new StdError.StdError({ code: \"invalid_input\", message: error.message }))\n    }\n    return yield* unknownFailure(error)\n  }\n\n  // Every update hunk is derived from the file as it is on disk, so two\n  // sections naming one path both start from the same original and the second\n  // write erases the first \u2014 while the summary reports two modifications.\n  // The preflight cannot honestly validate the second section against a file\n  // the first has not written yet, so the patch is refused whole rather than\n  // applied by halves. A file needing several edits carries several `@@`\n  // chunks inside one section, which is the shape the parser already accepts.\n  // Resolve against the injected workspace, then follow existing filesystem\n  // aliases. For a new file, resolve its parent (which may be a symlink).\n  const identity = (value: string) => {\n    const resolved = path.resolve(value)\n    return fileSystem.realPath(resolved).pipe(\n      Effect.catch((error) =>\n        error.reason._tag === \"NotFound\"\n          ? fileSystem.realPath(path.dirname(resolved)).pipe(\n            Effect.map((parent) => path.resolve(parent, path.basename(resolved))),\n            Effect.catch((parentError) =>\n              parentError.reason._tag === \"NotFound\"\n                ? Effect.succeed(resolved)\n                : Effect.fail(parentError)\n            )\n          )\n          : Effect.fail(error)\n      ),\n      Effect.mapError(FsFailure.denied(value, () =>\n        new StdError.StdError({\n          code: \"command_failed\",\n          message: `Failed to resolve patch path ${value}`,\n          path: value\n        })))\n    )\n  }\n  const touched = new Set<string>()\n  for (const hunk of parsed.hunks) {\n    const source = yield* identity(hunk.path)\n    const destination = hunk.kind === \"update\" && hunk.movePath !== undefined\n      ? yield* identity(hunk.movePath)\n      : undefined\n    const claims: Array<[string, string]> = [[hunk.path, source]]\n    if (hunk.kind === \"update\" && hunk.movePath !== undefined && destination !== source) {\n      claims.push([hunk.movePath, destination!])\n    }\n    for (const [claimed, key] of claims) {\n      if (touched.has(key)) {\n        return yield* Effect.fail(\n          new StdError.StdError({\n            code: \"invalid_input\",\n            message: `The patch names ${claimed} in more than one section; give one section per path`,\n            path: claimed\n          })\n        )\n      }\n      touched.add(key)\n    }\n  }\n\n  yield* FileMutation.validate(\n    fileSystem,\n    parsed.hunks.flatMap((hunk) =>\n      hunk.kind === \"update\" && hunk.movePath !== undefined ? [hunk.path, hunk.movePath] : [hunk.path]\n    )\n  )\n\n  // Create only parents the patch already intends to create, before taking\n  // stable sibling locks for new destinations as well as existing sources.\n  for (const hunk of parsed.hunks) {\n    const destination = hunk.kind === \"add\" ? hunk.path : hunk.kind === \"update\" ? hunk.movePath : undefined\n    if (destination !== undefined && !FileMutation.isVersioned(fileSystem)) {\n      yield* fileSystem.makeDirectory(path.dirname(destination), { recursive: true }).pipe(\n        Effect.mapError(\n          FsFailure.denied(destination, () =>\n            new StdError.StdError({\n              code: \"command_failed\",\n              message: `Failed to create parent directories for ${destination}`,\n              path: destination\n            }))\n        )\n      )\n    }\n  }\n  return yield* Effect.scoped(Effect.gen(function*() {\n    const mutation = yield* FileMutation.acquire(\n      fileSystem,\n      parsed.hunks.flatMap((hunk) =>\n        hunk.kind === \"update\" && hunk.movePath !== undefined ? [hunk.path, hunk.movePath] : [hunk.path]\n      ),\n      path\n    )\n    const added: Array<string> = []\n    const modified: Array<string> = []\n    const deleted: Array<string> = []\n    const prepared = new Map<ApplyPatchText.Hunk, string>()\n\n    for (const hunk of parsed.hunks) {\n      if (hunk.kind !== \"update\") continue\n      const bytes = yield* mutation.read(\n        hunk.path,\n        fileSystem.readFile(hunk.path).pipe(\n          Effect.mapError(FsFailure.reading(hunk.path, `Failed to read file to update ${hunk.path}`))\n        )\n      )\n      if (bytes.includes(0)) {\n        return yield* Effect.fail(\n          new StdError.StdError({\n            code: \"binary_file\",\n            message: `Cannot read binary file: ${hunk.path}`,\n            path: hunk.path\n          })\n        )\n      }\n      const original = yield* Effect.try({\n        try: () => decoder.decode(bytes),\n        catch: () =>\n          new StdError.StdError({\n            code: \"binary_file\",\n            message: `File is not valid UTF-8: ${hunk.path}`,\n            path: hunk.path\n          })\n      })\n      let contents: string\n      try {\n        contents = ApplyPatchText.deriveNewContents(original, hunk.path, hunk.chunks)\n      } catch (error) {\n        if (error instanceof ApplyPatchText.ComputeReplacementsError) {\n          return yield* Effect.fail(\n            new StdError.StdError({ code: \"no_match\", message: error.message, path: hunk.path })\n          )\n        }\n        return yield* unknownFailure(error, hunk.path)\n      }\n      prepared.set(hunk, contents)\n    }\n\n    // Prepare one complete provider request before touching any file. A move\n    // carries both its destination write and source removal in the same commit.\n    const changes: Array<FileMutation.Change> = []\n    const moves = new Set<ApplyPatchText.Hunk>()\n    for (const hunk of parsed.hunks) {\n      if (hunk.kind === \"delete\") {\n        changes.push({ path: hunk.path, content: null })\n      } else if (hunk.kind === \"add\") {\n        changes.push({ path: hunk.path, content: encoder.encode(hunk.contents) })\n      } else {\n        changes.push({\n          path: hunk.movePath ?? hunk.path,\n          content: encoder.encode(prepared.get(hunk))\n        })\n        if (hunk.movePath !== undefined && (yield* identity(hunk.movePath)) !== (yield* identity(hunk.path))) {\n          moves.add(hunk)\n          changes.push({ path: hunk.path, content: null })\n        }\n      }\n    }\n\n    // A denial names itself, so the model does not retry a write the host refuses.\n    const mutationFailure =\n      (code: StdError.Code, message: string, offendingPath: string) =>\n      (error: PlatformError.PlatformError): StdError.StdError =>\n        error.reason._tag === \"PermissionDenied\"\n          ? mutationError(\"permission_denied\", `Permission denied: ${offendingPath}`, offendingPath)\n          : mutationError(code, message, offendingPath)\n    const mutationError = (code: StdError.Code, message: string, offendingPath: string): StdError.StdError =>\n      new StdError.StdError({\n        code,\n        message: `${message}; applied before failure: added=${JSON.stringify(added)}, modified=${\n          JSON.stringify(modified)\n        }, deleted=${JSON.stringify(deleted)}`,\n        path: offendingPath\n      })\n\n    yield* mutation.commit(\n      changes,\n      Effect.gen(function*() {\n        for (const hunk of parsed.hunks) {\n          switch (hunk.kind) {\n            case \"add\": {\n              yield* fileSystem.writeFile(hunk.path, encoder.encode(hunk.contents)).pipe(\n                Effect.mapError(mutationFailure(\"command_failed\", `Failed to write file ${hunk.path}`, hunk.path))\n              )\n              added.push(hunk.path)\n              break\n            }\n            case \"delete\": {\n              yield* fileSystem.remove(hunk.path).pipe(\n                Effect.mapError(mutationFailure(\"not_found\", `Failed to delete file ${hunk.path}`, hunk.path))\n              )\n              deleted.push(hunk.path)\n              break\n            }\n            case \"update\": {\n              const contents = prepared.get(hunk)!\n              const destination = hunk.movePath ?? hunk.path\n              yield* Preserve.writeFile(fileSystem, destination, encoder.encode(contents)).pipe(\n                Effect.mapError((error) =>\n                  error.reason.method === \"chmod\"\n                    ? mutationError(\n                      \"command_failed\",\n                      `Could not preserve the mode of ${destination} before replacement by chmod`,\n                      destination\n                    )\n                    : mutationFailure(\"command_failed\", `Failed to write file ${destination}`, destination)(error)\n                )\n              )\n              modified.push(destination)\n              if (moves.has(hunk)) {\n                yield* fileSystem.remove(hunk.path).pipe(\n                  Effect.mapError(\n                    mutationFailure(\"command_failed\", `Failed to remove original ${hunk.path}`, hunk.path)\n                  )\n                )\n              }\n              break\n            }\n          }\n        }\n      })\n    )\n\n    // Publish diagnostics only after the whole provider operation succeeds.\n    for (const change of changes) {\n      if (change.content === null) yield* Diagnostics.close(path.resolve(change.path))\n      else yield* Diagnostics.sync(path.resolve(change.path), decoder.decode(change.content))\n    }\n    const summary = {\n      added: parsed.hunks.filter((hunk) => hunk.kind === \"add\").map((hunk) => hunk.path),\n      deleted: parsed.hunks.filter((hunk) => hunk.kind === \"delete\").map((hunk) => hunk.path),\n      modified: parsed.hunks.filter((hunk) => hunk.kind === \"update\").map((hunk) => hunk.movePath ?? hunk.path)\n    }\n\n    return {\n      output: ApplyPatchText.printSummary(summary),\n      ...summary\n    }\n  }))\n})\n"],
+  "mappings": "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",
+  "names": []
+}