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

package/dist/cjs/Container.js

@@ -0,0 +1,113 @@
+"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 name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __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 Container_exports = {};
+__export(Container_exports, {
+  Container: () => Container,
+  layerCommand: () => layerCommand,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeCommand: () => makeCommand,
+  makeNoop: () => makeNoop,
+  unavailable: () => unavailable
+});
+module.exports = __toCommonJS(Container_exports);
+var import_effect = require("effect");
+var StdError = __toESM(require("./StdError.js"), 1);
+const Container = import_effect.Context.Service("@smthrs/std/Container");
+const make = (service) => Container.of(service);
+const unavailable = (container) => new StdError.StdError({
+  code: "provider_unavailable",
+  message: `This host has no container transport, so it cannot run anything in "${container}". Drop the container field and run the command here, or ask the host to bind one.`
+});
+const makeNoop = () => make({ exec: (request) => import_effect.Effect.fail(unavailable(request.container)) });
+const layerNoop = import_effect.Layer.succeed(Container, makeNoop());
+const environmentName = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const forwardedPrefix = "SMITHERS_CONTAINER_ENV_";
+const rename = (names) => [
+  ...names.map((key) => `${key}="$${forwardedPrefix}${key}"; export ${key}; unset ${forwardedPrefix}${key}`),
+  `exec "$@"`
+].join("; ");
+const makeCommand = (options) => {
+  const program = options?.program ?? "docker";
+  return make({
+    exec: (request) => {
+      const env = request.env;
+      const entries = Object.entries(env ?? {});
+      const names = entries.map(([key]) => key);
+      const invalid = names.find((key) => !environmentName.test(key));
+      if (invalid !== void 0) {
+        return import_effect.Effect.fail(
+          new StdError.StdError({
+            code: "invalid_input",
+            message: `Environment variable names must match ${environmentName.source}: ${invalid}`
+          })
+        );
+      }
+      if (request.container === "" || request.container.startsWith("-")) {
+        return import_effect.Effect.fail(
+          new StdError.StdError({
+            code: "invalid_input",
+            message: `Container name must be non-empty and cannot start with '-': ${request.container}`,
+            path: request.container
+          })
+        );
+      }
+      const args = Array.from(request.args);
+      if (args.some((arg) => typeof arg !== "string")) {
+        return import_effect.Effect.fail(
+          new StdError.StdError({
+            code: "invalid_input",
+            message: "Container arguments must be a dense array of strings."
+          })
+        );
+      }
+      return import_effect.Effect.succeed({
+        file: program,
+        args: [
+          "exec",
+          ...request.stdin ? ["-i"] : [],
+          ...request.cwd === void 0 ? [] : ["-w", request.cwd],
+          ...names.flatMap((key) => ["-e", `${forwardedPrefix}${key}`]),
+          "--",
+          request.container,
+          ...names.length === 0 ? [] : ["sh", "-c", rename(names), "sh"],
+          request.file,
+          ...args
+        ],
+        ...env === void 0 ? {} : {
+          env: Object.fromEntries(
+            entries.map(([key, value]) => [`${forwardedPrefix}${key}`, value])
+          )
+        }
+      });
+    }
+  });
+};
+const layerCommand = (options) => import_effect.Layer.succeed(Container, makeCommand(options));
+//# sourceMappingURL=Container.js.map

package/dist/cjs/Container.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Container.ts"],
+  "sourcesContent": ["/**\n * The host's route into a named container, as an injected transport.\n *\n * A task whose interpreter, dependencies, and test runner live in a container\n * makes every command a nested quoting problem: the agent writes\n * `docker exec c bash -lc 'cd /testbed && python - <<EOF \u2026 EOF'`, and one layer\n * of that stack eats a quote. The measured cost across the 45-instance program\n * was twelve failed probes, one instance's single most expensive frame\n * (astropy-8707, which produced a probe that never ran), and a class of failure\n * that turns from a broken probe into a broken *edit* the moment the same\n * quoting reaches a writing command.\n *\n * So the transport is the harness's, not the agent's. A caller names the\n * container and passes its program and payload as data; this service turns that\n * into the argv the host actually spawns. `docker` and `podman` share the CLI\n * {@link makeCommand} builds, and a host with a different route supplies its own\n * {@link make} rather than teaching the agent a new incantation.\n *\n * A host that has no container route provides {@link makeNoop}, whose refusal\n * says so plainly. Nothing here shells out on its own: it only decides an argv,\n * and `bash` spawns it through the same permission-aware spawner as everything\n * else.\n *\n * @since 1.0.0\n */\n\nimport { Context, Effect, Layer } from \"effect\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * One command to run inside a container.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Request {\n  readonly container: string\n  readonly file: string\n  readonly args: ReadonlyArray<string>\n  readonly cwd?: string | undefined\n  readonly env?: Record<string, string> | undefined\n  /** Whether the payload arrives on the program's standard input. */\n  readonly stdin: boolean\n}\n\n/**\n * The argv the host spawns to satisfy a {@link Request}.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Plan {\n  readonly file: string\n  readonly args: ReadonlyArray<string>\n  /** Environment overrides for the transport process, never rendered as argv. */\n  readonly env?: Record<string, string> | undefined\n}\n\n/**\n * The one container transport contract.\n *\n * @category services\n * @since 1.0.0\n */\nexport interface Container {\n  readonly exec: (request: Request) => Effect.Effect<Plan, StdError.StdError>\n}\n\n/**\n * The {@link Container} service tag.\n *\n * @category services\n * @since 1.0.0\n */\nexport const Container: Context.Service<Container, Container> = Context.Service(\"@smthrs/std/Container\")\n\n/**\n * Builds a container transport from its one operation.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (service: Container): Container => Container.of(service)\n\n/**\n * The refusal a host with no container route answers with.\n *\n * @category errors\n * @since 1.0.0\n */\nexport const unavailable = (container: string): StdError.StdError =>\n  new StdError.StdError({\n    code: \"provider_unavailable\",\n    message:\n      `This host has no container transport, so it cannot run anything in \"${container}\". Drop the container field and run the command here, or ask the host to bind one.`\n  })\n\n/**\n * Builds the transport for a host with no container route.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const makeNoop = (): Container => make({ exec: (request) => Effect.fail(unavailable(request.container)) })\n\n/**\n * Provides {@link makeNoop}.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layerNoop: Layer.Layer<Container> = Layer.succeed(Container, makeNoop())\n\n/** The names a forwarded environment variable may take: a POSIX shell name. */\nconst environmentName = /^[A-Za-z_][A-Za-z0-9_]*$/\n\n/** The prefix a forwarded variable carries on the host transport process. */\nconst forwardedPrefix = \"SMITHERS_CONTAINER_ENV_\"\n\n/** The in-container script that renames each forwarded variable, then runs the program. */\nconst rename = (names: ReadonlyArray<string>): string =>\n  [\n    ...names.map((key) => `${key}=\"$${forwardedPrefix}${key}\"; export ${key}; unset ${forwardedPrefix}${key}`),\n    `exec \"$@\"`\n  ].join(\"; \")\n\n/**\n * Builds a transport over a `docker exec`-compatible CLI.\n *\n * `-i` is attached only when the payload arrives on standard input, because a\n * container CLI that holds stdin open for a command that never reads it makes\n * that command hang.\n *\n * Requested environment variables never reach the transport process under\n * their own names. The request's `env` is the caller's, and the transport is a\n * host program: `PATH`, `LD_PRELOAD`, `DOCKER_HOST` or `XDG_CONFIG_HOME` set on\n * it would choose what runs on the host. Each value therefore travels in\n * {@link Plan.env} under `SMITHERS_CONTAINER_ENV_`, is forwarded by that name\n * (`-e SMITHERS_CONTAINER_ENV_KEY`), and a `sh` inside the container renames it\n * to `KEY` before `exec`ing the program. Values stay out of the argv. A name\n * must be a POSIX shell name. A request with `env` therefore requires `sh` in\n * the container; one without `env` runs the program directly, so an image\n * without a shell works only for requests that carry no `env`.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const makeCommand = (options?: { readonly program?: string | undefined }): Container => {\n  const program = options?.program ?? \"docker\"\n  return make({\n    exec: (request) => {\n      const env = request.env\n      const entries = Object.entries(env ?? {})\n      const names = entries.map(([key]) => key)\n      const invalid = names.find((key) => !environmentName.test(key))\n      if (invalid !== undefined) {\n        return Effect.fail(\n          new StdError.StdError({\n            code: \"invalid_input\",\n            message: `Environment variable names must match ${environmentName.source}: ${invalid}`\n          })\n        )\n      }\n      if (request.container === \"\" || request.container.startsWith(\"-\")) {\n        return Effect.fail(\n          new StdError.StdError({\n            code: \"invalid_input\",\n            message: `Container name must be non-empty and cannot start with '-': ${request.container}`,\n            path: request.container\n          })\n        )\n      }\n      const args = Array.from(request.args)\n      if (args.some((arg) => typeof arg !== \"string\")) {\n        return Effect.fail(\n          new StdError.StdError({\n            code: \"invalid_input\",\n            message: \"Container arguments must be a dense array of strings.\"\n          })\n        )\n      }\n      return Effect.succeed({\n        file: program,\n        args: [\n          \"exec\",\n          ...(request.stdin ? [\"-i\"] : []),\n          ...(request.cwd === undefined ? [] : [\"-w\", request.cwd]),\n          ...names.flatMap((key) => [\"-e\", `${forwardedPrefix}${key}`]),\n          \"--\",\n          request.container,\n          ...(names.length === 0 ? [] : [\"sh\", \"-c\", rename(names), \"sh\"]),\n          request.file,\n          ...args\n        ],\n        ...(env === undefined ? {} : {\n          env: Object.fromEntries(\n            entries.map(([key, value]) => [`${forwardedPrefix}${key}`, value])\n          )\n        })\n      })\n    }\n  })\n}\n\n/**\n * Provides {@link makeCommand}.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layerCommand = (options?: { readonly program?: string | undefined }): Layer.Layer<Container> =>\n  Layer.succeed(Container, makeCommand(options))\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/Edit.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Edit flow declaration and portable handler.
+ *
+ * Three rules, each of them paid for by a measured failure:
+ *
+ * 1. **Exact or loud.** The anchor matches the file's bytes or the call fails
+ *    with the file's actual bytes at the nearest region. No fuzzy apply reports
+ *    success (sympy-15380 corrupted a file that way), and no failure returns a
+ *    bare `null` (sphinx-7590 abandoned a correct edit twice against one).
+ * 2. **Anchors by reference.** A prior `grep` or `read` already located the
+ *    region; `startLine`/`endLine` re-use that hit instead of retyping the text,
+ *    and `expect` turns the retyped copy into a checked assertion rather than a
+ *    search key.
+ * 3. **The hunk comes back.** The result carries the applied region as raw text
+ *    with its line range, so a mis-indented edit costs one glance instead of an
+ *    investigation (sphinx-7233 lost its verdict to a hunk nobody could see).
+ *    With a `LanguageServer` bound, the file's errors after the edit come back
+ *    too.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Schema from "effect/Schema";
+import * as StdError from "./StdError.ts";
+/**
+ * Registry name for the edit flow.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const name = "edit";
+/**
+ * Model-facing description of the edit flow.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export declare const description = "Edit a file by exact text (oldString, unique unless replaceAll) or by an earlier hit's line range (startLine/endLine, optional expect). A miss returns the file's real text; a hit returns the hunk.";
+/**
+ * Input schema for the edit flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Input: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly oldString: Schema.optional<Schema.String>;
+    readonly startLine: Schema.optional<Schema.Int>;
+    readonly endLine: Schema.optional<Schema.Int>;
+    readonly expect: Schema.optional<Schema.String>;
+    readonly newString: Schema.String;
+    readonly replaceAll: Schema.optional<Schema.Boolean>;
+}>;
+/**
+ * Decoded input accepted by the `edit` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Output schema for the edit flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Output: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly replacements: Schema.Number;
+    readonly startLine: Schema.Number;
+    readonly endLine: Schema.Number;
+    readonly hunk: Schema.String;
+    readonly errors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly line: Schema.Number;
+        readonly character: Schema.Number;
+        readonly message: Schema.String;
+    }>>>;
+}>;
+/**
+ * Decoded output returned by the `edit` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Static conservative effect envelope for the edit flow.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the edit effect envelope to one input path.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (input: typeof Input.Type) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * Capabilities required by the edit flow.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: string[];
+/**
+ * Declaration-only edit flow.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    readonly name: "edit";
+    readonly description: "Edit a file by exact text (oldString, unique unless replaceAll) or by an earlier hit's line range (startLine/endLine, optional expect). A miss returns the file's real text; a hit returns the hunk.";
+    readonly input: Schema.Struct<{
+        readonly path: Schema.String;
+        readonly oldString: Schema.optional<Schema.String>;
+        readonly startLine: Schema.optional<Schema.Int>;
+        readonly endLine: Schema.optional<Schema.Int>;
+        readonly expect: Schema.optional<Schema.String>;
+        readonly newString: Schema.String;
+        readonly replaceAll: Schema.optional<Schema.Boolean>;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly path: Schema.String;
+        readonly replacements: Schema.Number;
+        readonly startLine: Schema.Number;
+        readonly endLine: Schema.Number;
+        readonly hunk: Schema.String;
+        readonly errors: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly line: Schema.Number;
+            readonly character: Schema.Number;
+            readonly message: Schema.String;
+        }>>>;
+    }>;
+    readonly capabilities: string[];
+    readonly effects: import("@smthrs/plan/Effects").Declaration;
+};
+/**
+ * What a call to this flow does, for a reader of a run.
+ *
+ * Display metadata only. `@smthrs/registry` `Descriptor.FlowActivity` is the
+ * governing vocabulary and `StandardFlows` binds this value onto the flow's
+ * descriptor, where the binding site checks it. `declarationDigest` excludes
+ * it, so declaring it cannot invalidate a call identity or a cached prompt.
+ *
+ * @category presentation
+ * @since 1.0.0-rc.0
+ */
+export declare const activity: "writes";
+/**
+ * How one recorded call to this flow reads: the verb for each settlement, the
+ * input field that is its subject, and the measured output fields a one-line
+ * summary may count.
+ *
+ * Display metadata only, governed by `@smthrs/registry`
+ * `Descriptor.CallPresentation` and checked where `StandardFlows` binds it.
+ *
+ * @category presentation
+ * @since 1.0.0-rc.0
+ */
+export declare const presentation: {
+    readonly verb: {
+        readonly pending: "editing";
+        readonly success: "edited";
+        readonly failure: "failed to edit";
+    };
+    readonly subject: "path";
+    readonly result: "edit";
+};
+/**
+ * Applies one exact-anchored edit through the permission-aware kernel filesystem.
+ *
+ * Every refusal names what the file actually holds. A non-unique match is a
+ * refusal rather than a silent first-match edit, and it reports the lines every
+ * occurrence sits on so the caller can widen the anchor without re-reading.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export declare const run: (input: {
+    readonly path: string;
+    readonly newString: string;
+    readonly replaceAll?: boolean | undefined;
+    readonly endLine?: number | undefined;
+    readonly oldString?: string | undefined;
+    readonly startLine?: number | undefined;
+    readonly expect?: string | undefined;
+}) => Effect.Effect<{
+    readonly hunk: string;
+    readonly path: string;
+    readonly endLine: number;
+    readonly startLine: number;
+    readonly replacements: number;
+    readonly errors?: readonly {
+        readonly line: number;
+        readonly character: number;
+        readonly message: string;
+    }[] | undefined;
+}, StdError.StdError, FileSystem.FileSystem>;
+//# sourceMappingURL=Edit.d.ts.map

package/dist/cjs/Edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Edit.d.ts","sourceRoot":"","sources":["../../src/Edit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAQvC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,WAAW,yMACgL,CAAA;AAExM;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;;EAgBhB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;EAWjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,4CAAuF,CAAA;AAE3G;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAK,CAAC,IAAI,+CAC6C,CAAA;AAEhG;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAgE,CAAA;AAEzF;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsF,CAAA;AAEvG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,EAAG,QAAiB,CAAA;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAIf,CAAA;AAgDV;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;4CAwId,CAAA"}

package/dist/cjs/Edit.js

@@ -0,0 +1,258 @@
+"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 Edit_exports = {};
+__export(Edit_exports, {
+  Input: () => Input,
+  Output: () => Output,
+  activity: () => activity,
+  capabilities: () => capabilities,
+  description: () => description,
+  effects: () => effects,
+  effectsFor: () => effectsFor,
+  flow: () => flow,
+  name: () => name,
+  presentation: () => presentation,
+  run: () => run
+});
+module.exports = __toCommonJS(Edit_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var Schema = __toESM(require("effect/Schema"), 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 Match = __toESM(require("./internal/Match.js"), 1);
+var Preserve = __toESM(require("./internal/Preserve.js"), 1);
+var import_Text = require("./internal/Text.js");
+var StdError = __toESM(require("./StdError.js"), 1);
+const name = "edit";
+const description = "Edit a file by exact text (oldString, unique unless replaceAll) or by an earlier hit's line range (startLine/endLine, optional expect). A miss returns the file's real text; a hit returns the hunk.";
+const Input = Schema.Struct({
+  path: Schema.String.annotate({ description: "Path of the file to edit" }),
+  oldString: Schema.optional(Schema.String).annotate({
+    description: "Exact text to replace, byte for byte, including surrounding context"
+  }),
+  startLine: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))).annotate({
+    description: "First 1-based line to replace, from a prior read or grep hit; pair with endLine"
+  }),
+  endLine: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))).annotate({
+    description: "Last 1-based line to replace, inclusive"
+  }),
+  expect: Schema.optional(Schema.String).annotate({
+    description: "What those lines currently hold; the edit fails loudly if they hold anything else"
+  }),
+  newString: Schema.String.annotate({ description: "Replacement text" }),
+  replaceAll: Schema.optional(Schema.Boolean).annotate({ description: "Replace every occurrence instead of one" })
+});
+const Output = Schema.Struct({
+  path: Schema.String.annotate({ description: "Path that was edited" }),
+  replacements: Schema.Number.annotate({ description: "Number of occurrences replaced" }),
+  startLine: Schema.Number.annotate({ description: "First 1-based line of the returned hunk" }),
+  endLine: Schema.Number.annotate({ description: "Last 1-based line of the returned hunk" }),
+  hunk: Schema.String.annotate({
+    description: "The edited region as it now stands, raw and with its exact indentation, plus two lines of context"
+  }),
+  errors: Schema.optional(Schema.Array(Diagnostics.Problem)).annotate({
+    description: "Errors the language server reports in the file after the edit; absent when no server answered"
+  })
+});
+const effects = (0, import_Declaration.envelope)({ tier: "compensable", mode: "hermetic", reads: ["/**"], writes: ["/**"] });
+const effectsFor = (input) => (0, import_Declaration.envelope)({ tier: "compensable", mode: "hermetic", reads: [input.path], writes: [input.path] });
+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: "editing", success: "edited", failure: "failed to edit" },
+  subject: "path",
+  result: "edit"
+};
+const invalid = (path, message) => new StdError.StdError({ code: "invalid_input", message, path });
+const miss = (path, content, needle, subject) => {
+  const region = Match.nearest(content, needle);
+  return new StdError.StdError({
+    code: "no_match",
+    message: region === void 0 ? `${subject} does not occur in ${path}, and no line of it occurs there either \u2014 this is the wrong file, or the region is not what you remember. Read it and anchor on what it actually holds.` : `${subject} does not occur in ${path}. Lines ${region.startLine}-${region.endLine} actually hold this, raw:
+${region.text}
+
+Copy the lines you meant from that text, or anchor by startLine/endLine instead.`,
+    path
+  });
+};
+const lineSpan = (path, content, startLine, endLine) => {
+  const lines = (0, import_Text.sourceLines)(content);
+  if (endLine < startLine) return invalid(path, `endLine ${endLine} is before startLine ${startLine}`);
+  if (startLine > lines.length) {
+    return new StdError.StdError({
+      code: "offset_out_of_range",
+      message: `${path} has ${lines.length} lines, so line ${startLine} is outside it`,
+      path
+    });
+  }
+  if (endLine > lines.length) {
+    return new StdError.StdError({
+      code: "offset_out_of_range",
+      message: `Requested endLine ${endLine}, but ${path} has ${lines.length} lines`,
+      path
+    });
+  }
+  const last = endLine;
+  let start = 0;
+  for (let index = 0; index < startLine - 1; index++) start += lines[index].length + 1;
+  let end = start;
+  for (let index = startLine - 1; index < last; index++) end += lines[index].length + (index === last - 1 ? 0 : 1);
+  return { start, end };
+};
+const run = Effect.fn("Edit.run")(function* (input) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const byLines = input.startLine !== void 0 || input.endLine !== void 0;
+  if (input.oldString !== void 0 && byLines) {
+    return yield* Effect.fail(
+      invalid(input.path, "Anchor by oldString or by startLine/endLine, not by both")
+    );
+  }
+  if (input.oldString === void 0 && !byLines) {
+    return yield* Effect.fail(
+      invalid(input.path, "Give either oldString or a startLine/endLine range; use the write flow to create a file")
+    );
+  }
+  if (byLines && (input.startLine === void 0 || input.endLine === void 0)) {
+    return yield* Effect.fail(invalid(input.path, "A line anchor needs both startLine and endLine"));
+  }
+  if (input.oldString === "") {
+    return yield* Effect.fail(
+      invalid(input.path, "oldString must not be empty; use the write flow to create a file")
+    );
+  }
+  if (input.oldString !== void 0 && input.expect !== void 0) {
+    return yield* Effect.fail(invalid(input.path, "expect cannot be used with oldString"));
+  }
+  if (byLines && input.replaceAll !== void 0) {
+    return yield* Effect.fail(invalid(input.path, "replaceAll cannot be used with startLine/endLine"));
+  }
+  const edited = yield* Effect.scoped(Effect.gen(function* () {
+    const mutation = yield* FileMutation.acquire(fileSystem, [input.path]);
+    const bytes = yield* mutation.read(
+      input.path,
+      fileSystem.readFile(input.path).pipe(
+        Effect.mapError(FsFailure.reading(input.path, `File not found: ${input.path}`))
+      )
+    );
+    if (bytes.includes(0)) {
+      return yield* Effect.fail(
+        new StdError.StdError({
+          code: "binary_file",
+          message: `Cannot read binary file: ${input.path}`,
+          path: input.path
+        })
+      );
+    }
+    const content = yield* Effect.try({
+      try: () => new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+      catch: () => new StdError.StdError({
+        code: "binary_file",
+        message: `File is not valid UTF-8: ${input.path}`,
+        path: input.path
+      })
+    });
+    const targets = [];
+    if (input.oldString !== void 0) {
+      const located = Match.locate(content, input.oldString);
+      if (located.length === 0) return yield* Effect.fail(miss(input.path, content, input.oldString, "oldString"));
+      if (located.length > 1 && input.replaceAll !== true) {
+        const at = located.map((span) => span.startLine).join(", ");
+        return yield* Effect.fail(
+          invalid(
+            input.path,
+            `oldString occurs ${located.length} times in ${input.path}, on lines ${at}; add surrounding context to pick one, anchor by startLine/endLine, or set replaceAll`
+          )
+        );
+      }
+      targets.push(...input.replaceAll === true ? located : [located[0]]);
+    } else {
+      const span = lineSpan(input.path, content, input.startLine, input.endLine);
+      if (span instanceof StdError.StdError) return yield* Effect.fail(span);
+      if (input.expect !== void 0 && content.slice(span.start, span.end) !== input.expect) {
+        return yield* Effect.fail(
+          new StdError.StdError({
+            code: "no_match",
+            message: `Lines ${input.startLine}-${input.endLine} of ${input.path} do not hold expect. They hold this, raw:
+${content.slice(span.start, span.end)}
+
+Re-read the file: it moved under the line numbers you anchored on.`,
+            path: input.path
+          })
+        );
+      }
+      targets.push(span);
+    }
+    let replaced = "";
+    let cursor = 0;
+    for (const span of targets) {
+      replaced += content.slice(cursor, span.start) + input.newString;
+      cursor = span.end;
+    }
+    replaced += content.slice(cursor);
+    yield* mutation.commit(
+      [{
+        path: input.path,
+        content: new TextEncoder().encode(replaced)
+      }],
+      Preserve.writeFileString(fileSystem, input.path, replaced).pipe(
+        Effect.mapError(
+          (error) => error.reason.method === "chmod" ? new StdError.StdError({
+            code: "command_failed",
+            message: `Could not preserve the mode of ${input.path} before replacement by chmod`,
+            path: input.path
+          }) : FsFailure.denied(input.path, () => new StdError.StdError({
+            code: "command_failed",
+            message: `Could not write ${input.path}`,
+            path: input.path
+          }))(
+            error
+          )
+        )
+      )
+    );
+    const server = yield* Diagnostics.sync(input.path, replaced);
+    const first = targets[0];
+    const applied = Match.hunk(replaced, first.start, first.start + input.newString.length);
+    const output = {
+      path: input.path,
+      replacements: targets.length,
+      startLine: applied.startLine,
+      endLine: applied.endLine,
+      hunk: applied.text
+    };
+    return { output, server };
+  }));
+  const errors = edited.server === void 0 ? void 0 : yield* Diagnostics.errorsOf(edited.server, input.path);
+  return errors === void 0 ? edited.output : { ...edited.output, errors };
+});
+//# sourceMappingURL=Edit.js.map

package/dist/cjs/Edit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Edit.ts"],
+  "sourcesContent": ["/**\n * Edit flow declaration and portable handler.\n *\n * Three rules, each of them paid for by a measured failure:\n *\n * 1. **Exact or loud.** The anchor matches the file's bytes or the call fails\n *    with the file's actual bytes at the nearest region. No fuzzy apply reports\n *    success (sympy-15380 corrupted a file that way), and no failure returns a\n *    bare `null` (sphinx-7590 abandoned a correct edit twice against one).\n * 2. **Anchors by reference.** A prior `grep` or `read` already located the\n *    region; `startLine`/`endLine` re-use that hit instead of retyping the text,\n *    and `expect` turns the retyped copy into a checked assertion rather than a\n *    search key.\n * 3. **The hunk comes back.** The result carries the applied region as raw text\n *    with its line range, so a mis-indented edit costs one glance instead of an\n *    investigation (sphinx-7233 lost its verdict to a hunk nobody could see).\n *    With a `LanguageServer` bound, the file's errors after the edit come back\n *    too.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as FileSystem from \"effect/FileSystem\"\nimport * as Schema from \"effect/Schema\"\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 Match from \"./internal/Match.ts\"\nimport * as Preserve from \"./internal/Preserve.ts\"\nimport { sourceLines } from \"./internal/Text.ts\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * Registry name for the edit flow.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const name = \"edit\"\n\n/**\n * Model-facing description of the edit flow.\n *\n * @category descriptions\n * @since 1.0.0\n */\nexport const description =\n  \"Edit a file by exact text (oldString, unique unless replaceAll) or by an earlier hit's line range (startLine/endLine, optional expect). A miss returns the file's real text; a hit returns the hunk.\"\n\n/**\n * Input schema for the edit flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Input = Schema.Struct({\n  path: Schema.String.annotate({ description: \"Path of the file to edit\" }),\n  oldString: Schema.optional(Schema.String).annotate({\n    description: \"Exact text to replace, byte for byte, including surrounding context\"\n  }),\n  startLine: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))).annotate({\n    description: \"First 1-based line to replace, from a prior read or grep hit; pair with endLine\"\n  }),\n  endLine: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))).annotate({\n    description: \"Last 1-based line to replace, inclusive\"\n  }),\n  expect: Schema.optional(Schema.String).annotate({\n    description: \"What those lines currently hold; the edit fails loudly if they hold anything else\"\n  }),\n  newString: Schema.String.annotate({ description: \"Replacement text\" }),\n  replaceAll: Schema.optional(Schema.Boolean).annotate({ description: \"Replace every occurrence instead of one\" })\n})\n\n/**\n * Decoded input accepted by the `edit` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * Output schema for the edit flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Schema.Struct({\n  path: Schema.String.annotate({ description: \"Path that was edited\" }),\n  replacements: Schema.Number.annotate({ description: \"Number of occurrences replaced\" }),\n  startLine: Schema.Number.annotate({ description: \"First 1-based line of the returned hunk\" }),\n  endLine: Schema.Number.annotate({ description: \"Last 1-based line of the returned hunk\" }),\n  hunk: Schema.String.annotate({\n    description: \"The edited region as it now stands, raw and with its exact indentation, plus two lines of context\"\n  }),\n  errors: Schema.optional(Schema.Array(Diagnostics.Problem)).annotate({\n    description: \"Errors the language server reports in the file after the edit; absent when no server answered\"\n  })\n})\n\n/**\n * Decoded output returned by the `edit` 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 edit 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 edit effect envelope to one input path.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effectsFor = (input: typeof Input.Type) =>\n  envelope({ tier: \"compensable\", mode: \"hermetic\", reads: [input.path], writes: [input.path] })\n\n/**\n * Capabilities required by the edit 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 edit 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: \"editing\", success: \"edited\", failure: \"failed to edit\" },\n  subject: \"path\",\n  result: \"edit\"\n} as const\n\nconst invalid = (path: string, message: string): StdError.StdError =>\n  new StdError.StdError({ code: \"invalid_input\", message, path })\n\n/** The failure text for an anchor that is not in the file, with the file's own bytes. */\nconst miss = (path: string, content: string, needle: string, subject: string): StdError.StdError => {\n  const region = Match.nearest(content, needle)\n  return new StdError.StdError({\n    code: \"no_match\",\n    message: region === undefined\n      ? `${subject} does not occur in ${path}, and no line of it occurs there either \u2014 this is the wrong file, or the region is not what you remember. Read it and anchor on what it actually holds.`\n      : `${subject} does not occur in ${path}. Lines ${region.startLine}-${region.endLine} actually hold this, raw:\\n${region.text}\\n\\nCopy the lines you meant from that text, or anchor by startLine/endLine instead.`,\n    path\n  })\n}\n\n/** The byte span of an inclusive 1-based line range, or the failure explaining why not. */\nconst lineSpan = (\n  path: string,\n  content: string,\n  startLine: number,\n  endLine: number\n): { readonly start: number; readonly end: number } | StdError.StdError => {\n  const lines = sourceLines(content)\n  if (endLine < startLine) return invalid(path, `endLine ${endLine} is before startLine ${startLine}`)\n  if (startLine > lines.length) {\n    return new StdError.StdError({\n      code: \"offset_out_of_range\",\n      message: `${path} has ${lines.length} lines, so line ${startLine} is outside it`,\n      path\n    })\n  }\n  if (endLine > lines.length) {\n    return new StdError.StdError({\n      code: \"offset_out_of_range\",\n      message: `Requested endLine ${endLine}, but ${path} has ${lines.length} lines`,\n      path\n    })\n  }\n  const last = endLine\n  let start = 0\n  for (let index = 0; index < startLine - 1; index++) start += lines[index]!.length + 1\n  let end = start\n  for (let index = startLine - 1; index < last; index++) end += lines[index]!.length + (index === last - 1 ? 0 : 1)\n  return { start, end }\n}\n\n/**\n * Applies one exact-anchored edit through the permission-aware kernel filesystem.\n *\n * Every refusal names what the file actually holds. A non-unique match is a\n * refusal rather than a silent first-match edit, and it reports the lines every\n * occurrence sits on so the caller can widen the anchor without re-reading.\n *\n * @category handlers\n * @since 1.0.0\n */\nexport const run = Effect.fn(\"Edit.run\")(function*(\n  input: typeof Input.Type\n): Effect.fn.Return<typeof Output.Type, StdError.StdError, FileSystem.FileSystem> {\n  const fileSystem = yield* FileSystem.FileSystem\n  const byLines = input.startLine !== undefined || input.endLine !== undefined\n  if (input.oldString !== undefined && byLines) {\n    return yield* Effect.fail(\n      invalid(input.path, \"Anchor by oldString or by startLine/endLine, not by both\")\n    )\n  }\n  if (input.oldString === undefined && !byLines) {\n    return yield* Effect.fail(\n      invalid(input.path, \"Give either oldString or a startLine/endLine range; use the write flow to create a file\")\n    )\n  }\n  if (byLines && (input.startLine === undefined || input.endLine === undefined)) {\n    return yield* Effect.fail(invalid(input.path, \"A line anchor needs both startLine and endLine\"))\n  }\n  if (input.oldString === \"\") {\n    return yield* Effect.fail(\n      invalid(input.path, \"oldString must not be empty; use the write flow to create a file\")\n    )\n  }\n  if (input.oldString !== undefined && input.expect !== undefined) {\n    return yield* Effect.fail(invalid(input.path, \"expect cannot be used with oldString\"))\n  }\n  if (byLines && input.replaceAll !== undefined) {\n    return yield* Effect.fail(invalid(input.path, \"replaceAll cannot be used with startLine/endLine\"))\n  }\n  const edited = yield* Effect.scoped(Effect.gen(function*() {\n    const mutation = yield* FileMutation.acquire(fileSystem, [input.path])\n    const bytes = yield* mutation.read(\n      input.path,\n      fileSystem.readFile(input.path).pipe(\n        Effect.mapError(FsFailure.reading(input.path, `File not found: ${input.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: ${input.path}`,\n          path: input.path\n        })\n      )\n    }\n    const content = yield* Effect.try({\n      try: () => new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes),\n      catch: () =>\n        new StdError.StdError({\n          code: \"binary_file\",\n          message: `File is not valid UTF-8: ${input.path}`,\n          path: input.path\n        })\n    })\n\n    const targets: Array<{ readonly start: number; readonly end: number }> = []\n    if (input.oldString !== undefined) {\n      const located = Match.locate(content, input.oldString)\n      if (located.length === 0) return yield* Effect.fail(miss(input.path, content, input.oldString, \"oldString\"))\n      if (located.length > 1 && input.replaceAll !== true) {\n        const at = located.map((span) => span.startLine).join(\", \")\n        return yield* Effect.fail(\n          invalid(\n            input.path,\n            `oldString occurs ${located.length} times in ${input.path}, on lines ${at}; add surrounding context to pick one, anchor by startLine/endLine, or set replaceAll`\n          )\n        )\n      }\n      targets.push(...(input.replaceAll === true ? located : [located[0]!]))\n    } else {\n      const span = lineSpan(input.path, content, input.startLine!, input.endLine!)\n      if (span instanceof StdError.StdError) return yield* Effect.fail(span)\n      if (input.expect !== undefined && content.slice(span.start, span.end) !== input.expect) {\n        return yield* Effect.fail(\n          new StdError.StdError({\n            code: \"no_match\",\n            message:\n              `Lines ${input.startLine}-${input.endLine} of ${input.path} do not hold expect. They hold this, raw:\\n${\n                content.slice(span.start, span.end)\n              }\\n\\nRe-read the file: it moved under the line numbers you anchored on.`,\n            path: input.path\n          })\n        )\n      }\n      targets.push(span)\n    }\n\n    let replaced = \"\"\n    let cursor = 0\n    for (const span of targets) {\n      replaced += content.slice(cursor, span.start) + input.newString\n      cursor = span.end\n    }\n    replaced += content.slice(cursor)\n    yield* mutation.commit(\n      [{\n        path: input.path,\n        content: new TextEncoder().encode(replaced)\n      }],\n      Preserve.writeFileString(fileSystem, input.path, replaced).pipe(\n        Effect.mapError((error) =>\n          error.reason.method === \"chmod\"\n            ? new StdError.StdError({\n              code: \"command_failed\",\n              message: `Could not preserve the mode of ${input.path} before replacement by chmod`,\n              path: input.path\n            })\n            : FsFailure.denied(input.path, () =>\n              new StdError.StdError({\n                code: \"command_failed\",\n                message: `Could not write ${input.path}`,\n                path: input.path\n              }))(\n                error\n              )\n        )\n      )\n    )\n    // Synced under the file lock, so a later edit's text never reaches the\n    // server before this one's.\n    const server = yield* Diagnostics.sync(input.path, replaced)\n    const first = targets[0]!\n    const applied = Match.hunk(replaced, first.start, first.start + input.newString.length)\n    const output: typeof Output.Type = {\n      path: input.path,\n      replacements: targets.length,\n      startLine: applied.startLine,\n      endLine: applied.endLine,\n      hunk: applied.text\n    }\n    return { output, server }\n  }))\n  // Without a synced text the server can only describe the file as it was.\n  const errors = edited.server === undefined ? undefined : yield* Diagnostics.errorsOf(edited.server, input.path)\n  return errors === undefined ? edited.output : { ...edited.output, errors }\n})\n"],
+  "mappings": "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",
+  "names": []
+}