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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Manifest.d.ts","sourceRoot":"","sources":["../../src/Manifest.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAcjC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAG3C;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBhB,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBnB,CAAA;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;qBAwEizB,CAAC;;;qBAA8tF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAtDtiH,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,0LAoBjB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,gFAWpB,CAAA"}

package/dist/cjs/Manifest.js

@@ -0,0 +1,144 @@
+"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 Manifest_exports = {};
+__export(Manifest_exports, {
+  effectsFor: () => effectsFor,
+  flows: () => flows,
+  handlers: () => handlers,
+  names: () => names,
+  readOnly: () => readOnly
+});
+module.exports = __toCommonJS(Manifest_exports);
+var ApplyPatch = __toESM(require("./ApplyPatch.js"), 1);
+var Bash = __toESM(require("./Bash.js"), 1);
+var Edit = __toESM(require("./Edit.js"), 1);
+var Explore = __toESM(require("./Explore.js"), 1);
+var Fetch = __toESM(require("./Fetch.js"), 1);
+var Glob = __toESM(require("./Glob.js"), 1);
+var Grep = __toESM(require("./Grep.js"), 1);
+var HttpPost = __toESM(require("./HttpPost.js"), 1);
+var Ls = __toESM(require("./Ls.js"), 1);
+var Lsp = __toESM(require("./Lsp.js"), 1);
+var Read = __toESM(require("./Read.js"), 1);
+var ShellCommand = __toESM(require("./ShellCommand.js"), 1);
+var TestRun = __toESM(require("./TestRun.js"), 1);
+var UpdatePlan = __toESM(require("./UpdatePlan.js"), 1);
+var WebFetch = __toESM(require("./WebFetch.js"), 1);
+var WebSearch = __toESM(require("./WebSearch.js"), 1);
+var Write = __toESM(require("./Write.js"), 1);
+const flows = Object.freeze({
+  [Read.name]: Read.flow,
+  [Write.name]: Write.flow,
+  [Edit.name]: Edit.flow,
+  [Ls.name]: Ls.flow,
+  [Glob.name]: Glob.flow,
+  [Grep.name]: Grep.flow,
+  [Bash.name]: Bash.flow,
+  [TestRun.name]: TestRun.flow,
+  [ShellCommand.name]: ShellCommand.flow,
+  [ApplyPatch.name]: ApplyPatch.flow,
+  [UpdatePlan.name]: UpdatePlan.flow,
+  [Fetch.name]: Fetch.flow,
+  [HttpPost.name]: HttpPost.flow,
+  [Explore.name]: Explore.flow,
+  [WebFetch.name]: WebFetch.flow,
+  [WebSearch.name]: WebSearch.flow,
+  [Lsp.name]: Lsp.flow
+});
+const handlers = Object.freeze({
+  [Read.name]: Read.run,
+  [Write.name]: Write.run,
+  [Edit.name]: Edit.run,
+  [Ls.name]: Ls.run,
+  [Glob.name]: Glob.run,
+  [Grep.name]: Grep.run,
+  [Bash.name]: Bash.run,
+  [TestRun.name]: TestRun.run,
+  [ShellCommand.name]: ShellCommand.run,
+  [ApplyPatch.name]: ApplyPatch.run,
+  [UpdatePlan.name]: UpdatePlan.run,
+  [Fetch.name]: Fetch.run,
+  [HttpPost.name]: HttpPost.run,
+  [WebFetch.name]: WebFetch.run,
+  [WebSearch.name]: WebSearch.run,
+  [Lsp.name]: Lsp.run
+});
+const effectsFor = Object.freeze({
+  [Read.name]: Read.effectsFor,
+  [Write.name]: Write.effectsFor,
+  [Edit.name]: Edit.effectsFor,
+  [Ls.name]: Ls.effectsFor,
+  [Glob.name]: Glob.effectsFor,
+  [Grep.name]: Grep.effectsFor,
+  [Bash.name]: Bash.effectsFor,
+  [TestRun.name]: TestRun.effectsFor,
+  [ShellCommand.name]: ShellCommand.effectsFor,
+  [ApplyPatch.name]: ApplyPatch.effectsFor,
+  [UpdatePlan.name]: UpdatePlan.effectsFor,
+  [Fetch.name]: Fetch.effectsFor,
+  [HttpPost.name]: HttpPost.effectsFor,
+  [Explore.name]: Explore.effectsFor,
+  [WebFetch.name]: WebFetch.effectsFor,
+  [WebSearch.name]: WebSearch.effectsFor,
+  [Lsp.name]: Lsp.effectsFor
+});
+const names = Object.freeze(
+  [
+    Read.name,
+    Write.name,
+    Edit.name,
+    Ls.name,
+    Glob.name,
+    Grep.name,
+    Bash.name,
+    TestRun.name,
+    ShellCommand.name,
+    ApplyPatch.name,
+    UpdatePlan.name,
+    Fetch.name,
+    HttpPost.name,
+    Explore.name,
+    WebFetch.name,
+    WebSearch.name,
+    Lsp.name
+  ]
+);
+const readOnly = Object.freeze(
+  [
+    Read.name,
+    Ls.name,
+    Glob.name,
+    Grep.name,
+    Fetch.name,
+    Explore.name,
+    WebFetch.name,
+    Lsp.name
+  ]
+);
+//# sourceMappingURL=Manifest.js.map

package/dist/cjs/Manifest.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Manifest.ts"],
+  "sourcesContent": ["/**\n * Built-in flow declarations and their separately supplied handlers.\n *\n * @since 1.0.0\n */\n\nimport * as ApplyPatch from \"./ApplyPatch.ts\"\nimport * as Bash from \"./Bash.ts\"\nimport * as Edit from \"./Edit.ts\"\nimport * as Explore from \"./Explore.ts\"\nimport * as Fetch from \"./Fetch.ts\"\nimport * as Glob from \"./Glob.ts\"\nimport * as Grep from \"./Grep.ts\"\nimport * as HttpPost from \"./HttpPost.ts\"\nimport * as Ls from \"./Ls.ts\"\nimport * as Lsp from \"./Lsp.ts\"\nimport * as Read from \"./Read.ts\"\nimport * as ShellCommand from \"./ShellCommand.ts\"\nimport * as TestRun from \"./TestRun.ts\"\nimport * as UpdatePlan from \"./UpdatePlan.ts\"\nimport * as WebFetch from \"./WebFetch.ts\"\nimport * as WebSearch from \"./WebSearch.ts\"\nimport * as Write from \"./Write.ts\"\n\n/**\n * Frozen name-to-declaration registry for every standard flow.\n *\n * @category registries\n * @since 1.0.0\n */\nexport const flows = Object.freeze({\n  [Read.name]: Read.flow,\n  [Write.name]: Write.flow,\n  [Edit.name]: Edit.flow,\n  [Ls.name]: Ls.flow,\n  [Glob.name]: Glob.flow,\n  [Grep.name]: Grep.flow,\n  [Bash.name]: Bash.flow,\n  [TestRun.name]: TestRun.flow,\n  [ShellCommand.name]: ShellCommand.flow,\n  [ApplyPatch.name]: ApplyPatch.flow,\n  [UpdatePlan.name]: UpdatePlan.flow,\n  [Fetch.name]: Fetch.flow,\n  [HttpPost.name]: HttpPost.flow,\n  [Explore.name]: Explore.flow,\n  [WebFetch.name]: WebFetch.flow,\n  [WebSearch.name]: WebSearch.flow,\n  [Lsp.name]: Lsp.flow\n})\n\n/**\n * Frozen name-to-handler registry for executable standard flows.\n *\n * Explore is dynamic and therefore has no handler entry.\n *\n * @category registries\n * @since 1.0.0\n */\nexport const handlers = Object.freeze({\n  [Read.name]: Read.run,\n  [Write.name]: Write.run,\n  [Edit.name]: Edit.run,\n  [Ls.name]: Ls.run,\n  [Glob.name]: Glob.run,\n  [Grep.name]: Grep.run,\n  [Bash.name]: Bash.run,\n  [TestRun.name]: TestRun.run,\n  [ShellCommand.name]: ShellCommand.run,\n  [ApplyPatch.name]: ApplyPatch.run,\n  [UpdatePlan.name]: UpdatePlan.run,\n  [Fetch.name]: Fetch.run,\n  [HttpPost.name]: HttpPost.run,\n  [WebFetch.name]: WebFetch.run,\n  [WebSearch.name]: WebSearch.run,\n  [Lsp.name]: Lsp.run\n})\n\n/**\n * Frozen name-to-narrowing registry: the entry point for `effectsFor`.\n *\n * Every flow declares a registry-time worst case in `flow.effects`, and every\n * module also narrows that declaration for one decoded input. Without this map\n * a host holding a flow name and a decoded input has no generic way to reach\n * the narrowing, so it would have to serialize conflicts against the worst case\n * for every call. Explore is included even though it has no handler entry: it\n * is a declaration a seat can be offered, and its envelope narrows the same way.\n *\n * @category registries\n * @since 1.0.0\n */\nexport const effectsFor = Object.freeze({\n  [Read.name]: Read.effectsFor,\n  [Write.name]: Write.effectsFor,\n  [Edit.name]: Edit.effectsFor,\n  [Ls.name]: Ls.effectsFor,\n  [Glob.name]: Glob.effectsFor,\n  [Grep.name]: Grep.effectsFor,\n  [Bash.name]: Bash.effectsFor,\n  [TestRun.name]: TestRun.effectsFor,\n  [ShellCommand.name]: ShellCommand.effectsFor,\n  [ApplyPatch.name]: ApplyPatch.effectsFor,\n  [UpdatePlan.name]: UpdatePlan.effectsFor,\n  [Fetch.name]: Fetch.effectsFor,\n  [HttpPost.name]: HttpPost.effectsFor,\n  [Explore.name]: Explore.effectsFor,\n  [WebFetch.name]: WebFetch.effectsFor,\n  [WebSearch.name]: WebSearch.effectsFor,\n  [Lsp.name]: Lsp.effectsFor\n})\n\n/**\n * Frozen standard flow names in registry order.\n *\n * @category metadata\n * @since 1.0.0\n */\nexport const names = Object.freeze(\n  [\n    Read.name,\n    Write.name,\n    Edit.name,\n    Ls.name,\n    Glob.name,\n    Grep.name,\n    Bash.name,\n    TestRun.name,\n    ShellCommand.name,\n    ApplyPatch.name,\n    UpdatePlan.name,\n    Fetch.name,\n    HttpPost.name,\n    Explore.name,\n    WebFetch.name,\n    WebSearch.name,\n    Lsp.name\n  ] as const\n)\n\n/**\n * Frozen names visible to a seat restricted to read-only flows.\n *\n * Seat policies consume this list instead of duplicating name checks.\n *\n * `websearch` is deliberately absent: its provider contract requires\n * `net:post` authority, which is mutating under the kernel capability\n * taxonomy, so it cannot ride in a read-only seat.\n *\n * @category visibility\n * @since 1.0.0\n */\nexport const readOnly = Object.freeze(\n  [\n    Read.name,\n    Ls.name,\n    Glob.name,\n    Grep.name,\n    Fetch.name,\n    Explore.name,\n    WebFetch.name,\n    Lsp.name\n  ] as const\n)\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/NativeSearch.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The `rg`-process implementation of the ripgrep search contract.
+ *
+ * @since 1.0.0
+ */
+import type * as ChildProcessSpawner from "@smthrs/kernel/ChildProcessSpawner";
+import * as Path from "@smthrs/kernel/Path";
+import { type Context, Layer } from "effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Search from "./Search.ts";
+/**
+ * Maximum bytes captured from either stream across one search operation.
+ *
+ * Native search refuses an overflow instead of truncating because a partial
+ * ripgrep stream could make it disagree with the portable peer. The 64 MiB
+ * bound is well above real repository listings: 400,000 paths occupy roughly
+ * 16 MiB in a typical `rg --files` stream.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const MAX_CAPTURE_BYTES = 67108864;
+/**
+ * Captures filesystem, path and process services in the native peer.
+ * Optional environment declarations overlay the host child-process allowlist.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (services: Context.Context<FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>, environment?: Readonly<Record<string, string>>) => Search.Search;
+/**
+ * Provides the `rg`-driven peer.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layer: Layer.Layer<Search.Search, never, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+//# sourceMappingURL=NativeSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeSearch.d.ts","sourceRoot":"","sources":["../../src/NativeSearch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,KAAK,mBAAmB,MAAM,oCAAoC,CAAA;AAC9E,OAAO,KAAK,IAAI,MAAM,qBAAqB,CAAA;AAC3C,OAAO,EAAE,KAAK,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAA;AACpD,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAK/C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAIrC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,WAAa,CAAA;AA8Y3C;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GACf,UAAU,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC,mBAAmB,CAAC,EACtG,cAAc,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAC7C,MAAM,CAAC,MAIN,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAC7B,MAAM,CAAC,MAAM,EACb,KAAK,EACL,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC,mBAAmB,CAI5E,CAAA"}

package/dist/cjs/NativeSearch.js

@@ -0,0 +1,326 @@
+"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 NativeSearch_exports = {};
+__export(NativeSearch_exports, {
+  MAX_CAPTURE_BYTES: () => MAX_CAPTURE_BYTES,
+  layer: () => layer,
+  make: () => make
+});
+module.exports = __toCommonJS(NativeSearch_exports);
+var Path = __toESM(require("@smthrs/kernel/Path"), 1);
+var import_effect = require("effect");
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var Exec = __toESM(require("./internal/Exec.js"), 1);
+var Grouping = __toESM(require("./internal/Grouping.js"), 1);
+var import_Text = require("./internal/Text.js");
+var Walk = __toESM(require("./internal/Walk.js"), 1);
+var Search = __toESM(require("./Search.js"), 1);
+var Contract = __toESM(require("./SearchContract.js"), 1);
+var StdError = __toESM(require("./StdError.js"), 1);
+const MAX_CAPTURE_BYTES = 67108864;
+const execute = (cwd, args, environment) => Exec.exec("rg", { args, cwd, env: environment, maxCaptureBytes: MAX_CAPTURE_BYTES, overflow: "refuse" }).pipe(
+  import_effect.Effect.mapError(
+    (error) => new StdError.StdError({
+      code: error.code === "capture_overflow" ? "command_failed" : "provider_unavailable",
+      message: error.code === "capture_overflow" ? error.message : "The native ripgrep implementation could not start rg"
+    })
+  )
+);
+const ignoreFlags = (noIgnore) => [
+  "--no-config",
+  "--no-require-git",
+  "--no-ignore-global",
+  "--no-ignore-parent",
+  "--no-ignore-exclude",
+  "--no-ignore-dot",
+  ...noIgnore ? ["--no-ignore"] : []
+];
+const rejection = (result) => {
+  const message = result.stderr.trim();
+  return result.exitCode > 1 && message.length > 0 ? message : void 0;
+};
+const nulSeparated = (stdout) => stdout.split("\0").filter((value) => value.length > 0);
+const preview = (line) => {
+  const withoutTerminator = line.replace(/\r?\n$/, "");
+  const characters = Array.from(withoutTerminator);
+  return (0, import_Text.truncateBytes)(characters.length > 500 ? characters.slice(0, 500).join("") : withoutTerminator, 500, {
+    keep: "head"
+  }).text;
+};
+const asRecord = (value) => typeof value === "object" && value !== null ? value : void 0;
+const textAt = (record, key) => {
+  const nested = asRecord(record?.[key]);
+  return typeof nested?.text === "string" ? nested.text : void 0;
+};
+const malformedJson = () => new StdError.StdError({ code: "request_failed", message: "rg returned malformed JSON" });
+const resolveRoot = (input, globs) => import_effect.Effect.gen(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const included = (relative, basename) => Contract.includedByGlobs(globs, relative, basename);
+  const walked = yield* Walk.files(fileSystem, path, input.root, input.hidden, input.noIgnore, included);
+  const cwd = walked.explicitFile ? path.dirname(input.root) : input.root;
+  const selected = walked.explicitFile ? walked.files : walked.files.filter((file) => included(Walk.relativeForPattern(path, input.root, file), path.basename(file)));
+  const links = walked.explicitFile ? [] : yield* Walk.symbolicLinks(fileSystem, selected);
+  return {
+    cwd,
+    targets: selected.filter((_, index) => links[index] !== true).map((file) => path.relative(cwd, file)),
+    explicitFile: walked.explicitFile,
+    ignored: walked.ignored,
+    absolute: (value) => path.normalize(path.join(cwd, value.replace(/^\.\//, "")))
+  };
+});
+const executeFiles = (cwd, args, targets, environment) => import_effect.Effect.gen(function* () {
+  if (targets.length === 0) {
+    return {
+      stdout: args.includes("--json") ? `${JSON.stringify({ type: "summary", data: { stats: { searches: 0 } } })}
+` : "",
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const encoder = new TextEncoder();
+  const batches = [];
+  let batch = [];
+  let size = 0;
+  for (const target of targets) {
+    const bytes = encoder.encode(target).length + 1;
+    if (batch.length > 0 && (batch.length >= 256 || size + bytes > 32768)) {
+      batches.push(batch);
+      batch = [];
+      size = 0;
+    }
+    batch.push(target);
+    size += bytes;
+  }
+  batches.push(batch);
+  let stdout = "";
+  let stderr = "";
+  let stdoutBytes = 0;
+  let stderrBytes = 0;
+  let exitCode = 0;
+  for (const batch2 of batches) {
+    const result = yield* execute(cwd, [...args, ...batch2], environment);
+    if (rejection(result) !== void 0) return result;
+    stdoutBytes += encoder.encode(result.stdout).length;
+    stderrBytes += encoder.encode(result.stderr).length;
+    if (stdoutBytes > MAX_CAPTURE_BYTES || stderrBytes > MAX_CAPTURE_BYTES) {
+      return yield* import_effect.Effect.fail(
+        new StdError.StdError({
+          code: "command_failed",
+          message: `rg ${stdoutBytes > MAX_CAPTURE_BYTES ? "stdout" : "stderr"} exceeded the ${MAX_CAPTURE_BYTES}-byte capture cap`
+        })
+      );
+    }
+    stdout += result.stdout;
+    stderr += result.stderr;
+    exitCode = Math.max(exitCode, result.exitCode);
+  }
+  return { stdout, stderr, exitCode };
+});
+const pathOrder = (left, right) => left.file < right.file ? -1 : left.file > right.file ? 1 : left.line - right.line;
+const capMatches = (lines, maxCount) => {
+  if (maxCount === void 0) return lines;
+  const counted = /* @__PURE__ */ new Map();
+  return lines.map((line) => {
+    if (line.kind !== "match") return line;
+    const seen = counted.get(line.file) ?? 0;
+    counted.set(line.file, seen + 1);
+    return seen < maxCount ? line : { ...line, kind: "context" };
+  });
+};
+const grep = (input, environment) => import_effect.Effect.gen(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const root = yield* resolveRoot(input, input.globs);
+  const args = [
+    "--json",
+    "--stats",
+    ...ignoreFlags(input.noIgnore),
+    "--no-messages",
+    "--sort",
+    "path",
+    "--encoding=utf-8",
+    "--crlf"
+  ];
+  if (input.hidden) args.push("--hidden");
+  if (input.fixedStrings) args.push("--fixed-strings");
+  if (input.ignoreCase) args.push("--ignore-case");
+  else if (input.smartCase) args.push("--smart-case");
+  if (input.beforeContext > 0) args.push("--before-context", String(input.beforeContext));
+  if (input.afterContext > 0) args.push("--after-context", String(input.afterContext));
+  if (input.maxCount !== void 0) args.push("--max-count", String(input.maxCount));
+  args.push("--", input.pattern);
+  const binaryArgs = [
+    "--files-with-matches",
+    "--text",
+    "--null",
+    ...ignoreFlags(input.noIgnore),
+    "--no-messages",
+    "--sort",
+    "path"
+  ];
+  if (input.hidden) binaryArgs.push("--hidden");
+  binaryArgs.push("--", "\\x00");
+  const [result, binaryResult] = yield* import_effect.Effect.all(
+    [
+      executeFiles(root.cwd, args, root.targets, environment),
+      executeFiles(root.cwd, binaryArgs, root.targets, environment)
+    ],
+    { concurrency: "unbounded" }
+  );
+  for (const outcome of [result, binaryResult]) {
+    const message = rejection(outcome);
+    if (message !== void 0) {
+      return yield* import_effect.Effect.fail(new StdError.StdError({ code: "request_failed", message }));
+    }
+  }
+  const binaryFiles = new Set(nulSeparated(binaryResult.stdout).map(root.absolute));
+  if (root.explicitFile && binaryFiles.size > 0) {
+    return yield* import_effect.Effect.fail(
+      new StdError.StdError({
+        code: "binary_file",
+        message: `Cannot search binary file: ${input.root}`,
+        path: input.root
+      })
+    );
+  }
+  const lines = [];
+  const files = /* @__PURE__ */ new Set();
+  let sawSummary = false;
+  for (const encoded of result.stdout.split("\n")) {
+    if (encoded.length === 0) continue;
+    let event;
+    try {
+      const decoded = JSON.parse(encoded);
+      const record = asRecord(decoded);
+      if (record === void 0) return yield* import_effect.Effect.fail(malformedJson());
+      event = record;
+    } catch {
+      return yield* import_effect.Effect.fail(malformedJson());
+    }
+    const type = event.type;
+    const data = asRecord(event.data);
+    if (type === "match" || type === "context") {
+      const file = textAt(data, "path");
+      const text = textAt(data, "lines");
+      const line = data?.line_number;
+      if (file === void 0 || text === void 0 || typeof line !== "number") {
+        return yield* import_effect.Effect.fail(malformedJson());
+      }
+      const absolute = root.absolute(file);
+      files.add(absolute);
+      lines.push({ file: absolute, line, text: preview(text), kind: type });
+    } else if (type === "begin") {
+      if (textAt(data, "path") === void 0) return yield* import_effect.Effect.fail(malformedJson());
+    } else if (type === "end") {
+      if (textAt(data, "path") === void 0 || data?.binary_offset !== null && typeof data?.binary_offset !== "number") return yield* import_effect.Effect.fail(malformedJson());
+    } else if (type === "summary") {
+      const stats = asRecord(data?.stats);
+      if (typeof stats?.searches !== "number") return yield* import_effect.Effect.fail(malformedJson());
+      sawSummary = true;
+    } else return yield* import_effect.Effect.fail(malformedJson());
+  }
+  if (!sawSummary) return yield* import_effect.Effect.fail(malformedJson());
+  for (const file of binaryFiles) files.delete(file);
+  const visibleLines = capMatches(
+    lines.filter((line) => !binaryFiles.has(line.file)).sort(pathOrder),
+    input.maxCount
+  );
+  const grouped = input.filesWithMatches ? [] : Grouping.group(visibleLines);
+  const entries = input.filesWithMatches ? [...files].sort() : grouped;
+  const truncated = entries.length > input.limit;
+  const shown = grouped.slice(0, input.limit);
+  const contents = /* @__PURE__ */ new Map();
+  if (input.symbols) {
+    for (const file of new Set(shown.map((match) => match.file))) {
+      const bytes = yield* import_effect.Effect.orElseSucceed(fileSystem.readFile(file), () => void 0);
+      if (bytes !== void 0) contents.set(file, Grouping.sourceLines(new TextDecoder().decode(bytes)));
+    }
+  }
+  const unsatisfiable = entries.length > 0 ? void 0 : yield* Contract.unsatisfiableNotice({
+    fileSystem,
+    path,
+    root: input.root,
+    globs: input.globs,
+    hidden: input.hidden,
+    noIgnore: input.noIgnore,
+    ignored: root.ignored
+  });
+  return {
+    matches: Grouping.annotate(shown, contents),
+    files: input.filesWithMatches ? [...files].sort().slice(0, input.limit) : [],
+    filesSearched: root.targets.length,
+    skippedBinary: binaryFiles.size,
+    truncated,
+    ...truncated ? { notice: (0, import_Text.notice)(input.filesWithMatches ? "files" : "matches", input.limit, entries.length) } : {},
+    ...unsatisfiable === void 0 ? {} : { notice: unsatisfiable }
+  };
+});
+const glob = (input, environment) => import_effect.Effect.gen(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const root = yield* resolveRoot(input, [input.pattern]);
+  const args = ["--files", "--null", ...ignoreFlags(input.noIgnore), "--no-messages", "--sort", "path"];
+  if (input.hidden) args.push("--hidden");
+  args.push("--");
+  const result = yield* executeFiles(root.cwd, args, root.targets, environment);
+  const rejected = rejection(result);
+  if (rejected !== void 0) {
+    return yield* import_effect.Effect.fail(new StdError.StdError({ code: "invalid_pattern", message: rejected }));
+  }
+  const paths = nulSeparated(result.stdout).map(root.absolute).filter(
+    (file) => root.explicitFile || Contract.includedByGlobs([input.pattern], Walk.relativeForPattern(path, input.root, file), path.basename(file))
+  ).sort();
+  const shown = paths.slice(0, input.limit);
+  const unsatisfiable = paths.length > 0 ? void 0 : yield* Contract.unsatisfiableNotice({
+    fileSystem,
+    path,
+    root: input.root,
+    globs: [input.pattern],
+    hidden: input.hidden,
+    noIgnore: input.noIgnore,
+    ignored: root.ignored
+  });
+  return {
+    paths: shown,
+    total: paths.length,
+    truncated: paths.length > input.limit,
+    ...paths.length > input.limit ? { notice: (0, import_Text.notice)("entries", shown.length, paths.length) } : {},
+    ...unsatisfiable === void 0 ? {} : { notice: unsatisfiable }
+  };
+});
+const make = (services, environment) => Search.make({
+  grep: (input) => import_effect.Effect.provide(grep(input, environment), services),
+  glob: (input) => import_effect.Effect.provide(glob(input, environment), services)
+});
+const layer = import_effect.Layer.effect(
+  Search.Search,
+  import_effect.Effect.map(import_effect.Effect.context(), make)
+);
+//# sourceMappingURL=NativeSearch.js.map

package/dist/cjs/NativeSearch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/NativeSearch.ts"],
+  "sourcesContent": ["/**\n * The `rg`-process implementation of the ripgrep search contract.\n *\n * @since 1.0.0\n */\n\nimport type * as ChildProcessSpawner from \"@smthrs/kernel/ChildProcessSpawner\"\nimport * as Path from \"@smthrs/kernel/Path\"\nimport { type Context, Effect, Layer } from \"effect\"\nimport * as FileSystem from \"effect/FileSystem\"\nimport * as Exec from \"./internal/Exec.ts\"\nimport * as Grouping from \"./internal/Grouping.ts\"\nimport { notice, truncateBytes } from \"./internal/Text.ts\"\nimport * as Walk from \"./internal/Walk.ts\"\nimport * as Search from \"./Search.ts\"\nimport * as Contract from \"./SearchContract.ts\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * Maximum bytes captured from either stream across one search operation.\n *\n * Native search refuses an overflow instead of truncating because a partial\n * ripgrep stream could make it disagree with the portable peer. The 64 MiB\n * bound is well above real repository listings: 400,000 paths occupy roughly\n * 16 MiB in a typical `rg --files` stream.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const MAX_CAPTURE_BYTES = 67_108_864\n\ninterface RgResult {\n  readonly stdout: string\n  readonly stderr: string\n  readonly exitCode: number\n}\n\nconst execute = (\n  cwd: string,\n  args: ReadonlyArray<string>,\n  environment: Readonly<Record<string, string>> | undefined\n): Effect.Effect<RgResult, StdError.StdError, ChildProcessSpawner.ChildProcessSpawner> =>\n  Exec.exec(\"rg\", { args, cwd, env: environment, maxCaptureBytes: MAX_CAPTURE_BYTES, overflow: \"refuse\" }).pipe(\n    Effect.mapError((error) =>\n      new StdError.StdError({\n        code: error.code === \"capture_overflow\" ? \"command_failed\" : \"provider_unavailable\",\n        message: error.code === \"capture_overflow\"\n          ? error.message\n          : \"The native ripgrep implementation could not start rg\"\n      })\n    )\n  )\n\n// Only .gitignore within the requested root participates. Disable user config,\n// parent/global rules and other ignore sources so the result is host independent.\nconst ignoreFlags = (noIgnore: boolean | undefined): ReadonlyArray<string> => [\n  \"--no-config\",\n  \"--no-require-git\",\n  \"--no-ignore-global\",\n  \"--no-ignore-parent\",\n  \"--no-ignore-exclude\",\n  \"--no-ignore-dot\",\n  ...(noIgnore ? [\"--no-ignore\"] : [])\n]\n\n/**\n * Reports what `rg` rejected, or `undefined` when it produced an answer.\n *\n * Exit status 2 means only \"an error occurred\", and a walk hits those\n * routinely: a dangling symlink, a symlink loop, a directory the process may\n * not list. `--no-messages` suppresses exactly those, leaving stderr empty and\n * the results on stdout complete for everything `rg` could reach \u2014 the same\n * entries the in-process peer skips, so the peers still agree. A fatal error \u2014\n * an unparsable glob, a rejected expression, a killed process \u2014 always writes\n * to stderr, which `--no-messages` does not touch. Stderr is therefore the\n * discriminator, and the exit status alone is not.\n */\nconst rejection = (result: RgResult): string | undefined => {\n  const message = result.stderr.trim()\n  return result.exitCode > 1 && message.length > 0 ? message : undefined\n}\n\nconst nulSeparated = (stdout: string): ReadonlyArray<string> => stdout.split(\"\\0\").filter((value) => value.length > 0)\n\nconst preview = (line: string): string => {\n  const withoutTerminator = line.replace(/\\r?\\n$/, \"\")\n  const characters = Array.from(withoutTerminator)\n  return truncateBytes(characters.length > 500 ? characters.slice(0, 500).join(\"\") : withoutTerminator, 500, {\n    keep: \"head\"\n  }).text\n}\n\nconst asRecord = (value: unknown): Record<string, unknown> | undefined =>\n  typeof value === \"object\" && value !== null ? value as Record<string, unknown> : undefined\n\nconst textAt = (record: Record<string, unknown> | undefined, key: string): string | undefined => {\n  const nested = asRecord(record?.[key])\n  return typeof nested?.text === \"string\" ? nested.text : undefined\n}\n\nconst malformedJson = (): StdError.StdError =>\n  new StdError.StdError({ code: \"request_failed\", message: \"rg returned malformed JSON\" })\n\n// rg releases differ on some gitignore grammar (for example BOMs and\n// unclosed character classes in 14 versus 15). Select paths through the same\n// walk as portable, then name them explicitly to rg. This also prevents a\n// positive caller glob from overriding ignore rules or scanning unrelated files.\nconst resolveRoot = (\n  input: Search.GrepInput | Search.GlobInput,\n  globs: ReadonlyArray<string>\n): Effect.Effect<\n  {\n    readonly cwd: string\n    readonly targets: ReadonlyArray<string>\n    readonly explicitFile: boolean\n    readonly ignored: boolean\n    readonly absolute: (value: string) => string\n  },\n  StdError.StdError,\n  FileSystem.FileSystem | Path.Path\n> =>\n  Effect.gen(function*() {\n    const fileSystem = yield* FileSystem.FileSystem\n    const path = yield* Path.Path\n    const included = (relative: string, basename: string) => Contract.includedByGlobs(globs, relative, basename)\n    const walked = yield* Walk.files(fileSystem, path, input.root, input.hidden, input.noIgnore, included)\n    const cwd = walked.explicitFile ? path.dirname(input.root) : input.root\n    const selected = walked.explicitFile ?\n      walked.files :\n      walked.files.filter((file) => included(Walk.relativeForPattern(path, input.root, file), path.basename(file)))\n    const links = walked.explicitFile ? [] : yield* Walk.symbolicLinks(fileSystem, selected)\n    return {\n      cwd,\n      targets: selected.filter((_, index) => links[index] !== true).map((file) => path.relative(cwd, file)),\n      explicitFile: walked.explicitFile,\n      ignored: walked.ignored,\n      absolute: (value: string) => path.normalize(path.join(cwd, value.replace(/^\\.\\//, \"\")))\n    }\n  })\n\n// Stay well below OS argv limits, including on trees with long UTF-8 names.\n// Only one batch per operation is live, and the aggregate capture keeps the\n// same refusal bound as a single invocation.\nconst executeFiles = (\n  cwd: string,\n  args: ReadonlyArray<string>,\n  targets: ReadonlyArray<string>,\n  environment: Readonly<Record<string, string>> | undefined\n): Effect.Effect<RgResult, StdError.StdError, ChildProcessSpawner.ChildProcessSpawner> =>\n  Effect.gen(function*() {\n    if (targets.length === 0) {\n      return {\n        stdout: args.includes(\"--json\")\n          ? `${JSON.stringify({ type: \"summary\", data: { stats: { searches: 0 } } })}\\n`\n          : \"\",\n        stderr: \"\",\n        exitCode: 0\n      }\n    }\n    const encoder = new TextEncoder()\n    const batches: Array<Array<string>> = []\n    let batch: Array<string> = []\n    let size = 0\n    for (const target of targets) {\n      const bytes = encoder.encode(target).length + 1\n      if (batch.length > 0 && (batch.length >= 256 || size + bytes > 32_768)) {\n        batches.push(batch)\n        batch = []\n        size = 0\n      }\n      batch.push(target)\n      size += bytes\n    }\n    batches.push(batch)\n    let stdout = \"\"\n    let stderr = \"\"\n    let stdoutBytes = 0\n    let stderrBytes = 0\n    let exitCode = 0\n    for (const batch of batches) {\n      const result = yield* execute(cwd, [...args, ...batch], environment)\n      if (rejection(result) !== undefined) return result\n      stdoutBytes += encoder.encode(result.stdout).length\n      stderrBytes += encoder.encode(result.stderr).length\n      if (stdoutBytes > MAX_CAPTURE_BYTES || stderrBytes > MAX_CAPTURE_BYTES) {\n        return yield* Effect.fail(\n          new StdError.StdError({\n            code: \"command_failed\",\n            message: `rg ${\n              stdoutBytes > MAX_CAPTURE_BYTES ? \"stdout\" : \"stderr\"\n            } exceeded the ${MAX_CAPTURE_BYTES}-byte capture cap`\n          })\n        )\n      }\n      stdout += result.stdout\n      stderr += result.stderr\n      exitCode = Math.max(exitCode, result.exitCode)\n    }\n    return { stdout, stderr, exitCode }\n  })\n\nconst pathOrder = (left: Search.GrepLine, right: Search.GrepLine): number =>\n  left.file < right.file ? -1 : left.file > right.file ? 1 : left.line - right.line\n\n/**\n * Holds `maxCount` to the per-file match budget the contract states.\n *\n * `rg` labels an after-context line as a `match` when that line matches too,\n * so `--max-count 2 --after-context 1` over three consecutive matching lines\n * prints three `match` rows \u2014 measured against ripgrep 14.1.1. The in-process\n * peer stops counting at the budget and carries the surplus line as context,\n * and the generated conformance run found the two peers answering that call\n * differently on four seeds. The surplus rows are demoted rather than dropped,\n * because the caller asked for that context and `rg` did print it. Rows arrive\n * sorted by file and line, so counting in order is counting per file.\n */\nconst capMatches = (\n  lines: ReadonlyArray<Search.GrepLine>,\n  maxCount: number | undefined\n): ReadonlyArray<Search.GrepLine> => {\n  if (maxCount === undefined) return lines\n  const counted = new Map<string, number>()\n  return lines.map((line) => {\n    if (line.kind !== \"match\") return line\n    const seen = counted.get(line.file) ?? 0\n    counted.set(line.file, seen + 1)\n    return seen < maxCount ? line : { ...line, kind: \"context\" as const }\n  })\n}\n\nconst grep = (\n  input: Search.GrepInput,\n  environment: Readonly<Record<string, string>> | undefined\n): Effect.Effect<\n  Search.GrepOutput,\n  StdError.StdError,\n  FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner\n> =>\n  Effect.gen(function*() {\n    const fileSystem = yield* FileSystem.FileSystem\n    const path = yield* Path.Path\n    const root = yield* resolveRoot(input, input.globs)\n    const args: Array<string> = [\n      \"--json\",\n      \"--stats\",\n      ...ignoreFlags(input.noIgnore),\n      \"--no-messages\",\n      \"--sort\",\n      \"path\",\n      \"--encoding=utf-8\",\n      \"--crlf\"\n    ]\n    if (input.hidden) args.push(\"--hidden\")\n    if (input.fixedStrings) args.push(\"--fixed-strings\")\n    // `rg` documents `--smart-case` as overriding `--ignore-case`, so passing\n    // both makes an uppercase pattern case-SENSITIVE. The in-process peer reads\n    // the pair the other way round \u2014 `ignoreCase || (smartCase && no uppercase)`\n    // \u2014 because an explicit request beats a heuristic. `Grep.run` refuses the\n    // combination outright, but a host binding `Search` directly never reaches\n    // that check, and the generated conformance run found the two peers\n    // answering seven seeds differently through it.\n    if (input.ignoreCase) args.push(\"--ignore-case\")\n    else if (input.smartCase) args.push(\"--smart-case\")\n    if (input.beforeContext > 0) args.push(\"--before-context\", String(input.beforeContext))\n    if (input.afterContext > 0) args.push(\"--after-context\", String(input.afterContext))\n    if (input.maxCount !== undefined) args.push(\"--max-count\", String(input.maxCount))\n    args.push(\"--\", input.pattern)\n\n    const binaryArgs: Array<string> = [\n      \"--files-with-matches\",\n      \"--text\",\n      \"--null\",\n      ...ignoreFlags(input.noIgnore),\n      \"--no-messages\",\n      \"--sort\",\n      \"path\"\n    ]\n    if (input.hidden) binaryArgs.push(\"--hidden\")\n    binaryArgs.push(\"--\", \"\\\\x00\")\n\n    const [result, binaryResult] = yield* Effect.all(\n      [\n        executeFiles(root.cwd, args, root.targets, environment),\n        executeFiles(root.cwd, binaryArgs, root.targets, environment)\n      ],\n      { concurrency: \"unbounded\" }\n    )\n    for (const outcome of [result, binaryResult]) {\n      const message = rejection(outcome)\n      if (message !== undefined) {\n        return yield* Effect.fail(new StdError.StdError({ code: \"request_failed\", message }))\n      }\n    }\n    const binaryFiles = new Set(nulSeparated(binaryResult.stdout).map(root.absolute))\n    if (root.explicitFile && binaryFiles.size > 0) {\n      return yield* Effect.fail(\n        new StdError.StdError({\n          code: \"binary_file\",\n          message: `Cannot search binary file: ${input.root}`,\n          path: input.root\n        })\n      )\n    }\n\n    const lines: Array<Search.GrepLine> = []\n    const files = new Set<string>()\n    let sawSummary = false\n    for (const encoded of result.stdout.split(\"\\n\")) {\n      if (encoded.length === 0) continue\n      let event: Record<string, unknown>\n      try {\n        const decoded = JSON.parse(encoded) as unknown\n        const record = asRecord(decoded)\n        if (record === undefined) return yield* Effect.fail(malformedJson())\n        event = record\n      } catch {\n        return yield* Effect.fail(malformedJson())\n      }\n      const type = event.type\n      const data = asRecord(event.data)\n      if (type === \"match\" || type === \"context\") {\n        const file = textAt(data, \"path\")\n        const text = textAt(data, \"lines\")\n        const line = data?.line_number\n        if (file === undefined || text === undefined || typeof line !== \"number\") {\n          return yield* Effect.fail(malformedJson())\n        }\n        const absolute = root.absolute(file)\n        files.add(absolute)\n        lines.push({ file: absolute, line, text: preview(text), kind: type })\n      } else if (type === \"begin\") {\n        if (textAt(data, \"path\") === undefined) return yield* Effect.fail(malformedJson())\n      } else if (type === \"end\") {\n        if (\n          textAt(data, \"path\") === undefined ||\n          (data?.binary_offset !== null && typeof data?.binary_offset !== \"number\")\n        ) return yield* Effect.fail(malformedJson())\n      } else if (type === \"summary\") {\n        const stats = asRecord(data?.stats)\n        if (typeof stats?.searches !== \"number\") return yield* Effect.fail(malformedJson())\n        sawSummary = true\n      } else return yield* Effect.fail(malformedJson())\n    }\n    if (!sawSummary) return yield* Effect.fail(malformedJson())\n    for (const file of binaryFiles) files.delete(file)\n    const visibleLines = capMatches(\n      lines.filter((line) => !binaryFiles.has(line.file)).sort(pathOrder),\n      input.maxCount\n    )\n    const grouped = input.filesWithMatches ? [] : Grouping.group(visibleLines)\n    const entries = input.filesWithMatches ? [...files].sort() : grouped\n    const truncated = entries.length > input.limit\n    const shown = grouped.slice(0, input.limit)\n    // `rg` reports lines, not files, so the enclosing definition costs one read\n    // of each file whose hits survived the limit \u2014 never one per file searched.\n    const contents = new Map<string, ReadonlyArray<string>>()\n    if (input.symbols) {\n      for (const file of new Set(shown.map((match) => match.file))) {\n        const bytes = yield* Effect.orElseSucceed(fileSystem.readFile(file), () => undefined)\n        if (bytes !== undefined) contents.set(file, Grouping.sourceLines(new TextDecoder().decode(bytes)))\n      }\n    }\n    const unsatisfiable = entries.length > 0 ? undefined : yield* Contract.unsatisfiableNotice({\n      fileSystem,\n      path,\n      root: input.root,\n      globs: input.globs,\n      hidden: input.hidden,\n      noIgnore: input.noIgnore,\n      ignored: root.ignored\n    })\n    return {\n      matches: Grouping.annotate(shown, contents),\n      files: input.filesWithMatches ? [...files].sort().slice(0, input.limit) : [],\n      filesSearched: root.targets.length,\n      skippedBinary: binaryFiles.size,\n      truncated,\n      ...(truncated\n        ? { notice: notice(input.filesWithMatches ? \"files\" : \"matches\", input.limit, entries.length) }\n        : {}),\n      ...(unsatisfiable === undefined ? {} : { notice: unsatisfiable })\n    }\n  })\n\nconst glob = (\n  input: Search.GlobInput,\n  environment: Readonly<Record<string, string>> | undefined\n): Effect.Effect<\n  Search.GlobOutput,\n  StdError.StdError,\n  FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner\n> =>\n  Effect.gen(function*() {\n    const fileSystem = yield* FileSystem.FileSystem\n    const path = yield* Path.Path\n    const root = yield* resolveRoot(input, [input.pattern])\n    const args: Array<string> = [\"--files\", \"--null\", ...ignoreFlags(input.noIgnore), \"--no-messages\", \"--sort\", \"path\"]\n    if (input.hidden) args.push(\"--hidden\")\n    args.push(\"--\")\n    const result = yield* executeFiles(root.cwd, args, root.targets, environment)\n    const rejected = rejection(result)\n    if (rejected !== undefined) {\n      return yield* Effect.fail(new StdError.StdError({ code: \"invalid_pattern\", message: rejected }))\n    }\n    const paths = nulSeparated(result.stdout).map(root.absolute).filter((file) =>\n      root.explicitFile ||\n      Contract.includedByGlobs([input.pattern], Walk.relativeForPattern(path, input.root, file), path.basename(file))\n    ).sort()\n    const shown = paths.slice(0, input.limit)\n    const unsatisfiable = paths.length > 0 ? undefined : yield* Contract.unsatisfiableNotice({\n      fileSystem,\n      path,\n      root: input.root,\n      globs: [input.pattern],\n      hidden: input.hidden,\n      noIgnore: input.noIgnore,\n      ignored: root.ignored\n    })\n    return {\n      paths: shown,\n      total: paths.length,\n      truncated: paths.length > input.limit,\n      ...(paths.length > input.limit ? { notice: notice(\"entries\", shown.length, paths.length) } : {}),\n      ...(unsatisfiable === undefined ? {} : { notice: unsatisfiable })\n    }\n  })\n\n/**\n * Captures filesystem, path and process services in the native peer.\n * Optional environment declarations overlay the host child-process allowlist.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (\n  services: Context.Context<FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>,\n  environment?: Readonly<Record<string, string>>\n): Search.Search =>\n  Search.make({\n    grep: (input) => Effect.provide(grep(input, environment), services),\n    glob: (input) => Effect.provide(glob(input, environment), services)\n  })\n\n/**\n * Provides the `rg`-driven peer.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layer: Layer.Layer<\n  Search.Search,\n  never,\n  FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner\n> = Layer.effect(\n  Search.Search,\n  Effect.map(Effect.context<FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>(), make)\n)\n"],
+  "mappings": "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",
+  "names": ["batch"]
+}