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

package/dist/cjs/RemoteSearch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/RemoteSearch.ts"],
+  "sourcesContent": ["/**\n * The search contract for a tree on another machine, in two round trips.\n *\n * `PortableSearch` asks `FileSystem` one question per directory, per entry\n * and per file. On a machine reached through a transport, such as a\n * benchmark's task container behind `docker exec`, every question is a\n * process start, so one `grep` over a 6,000-file repository is some 20,000 of\n * them. This peer asks the machine's own shell twice instead. `find` lists\n * the tree under the root, leaving out the directories every walk skips, and\n * `tar` returns its `.gitignore` files with the listing. The in-process peer\n * then decides which files the search reads, a second `tar` returns exactly\n * those, and `PortableSearch` answers over that copy. Every result, notice,\n * and refusal is therefore the in-process peer's own: this module decides\n * only where the bytes come from.\n *\n * It runs through the machine's own `ChildProcessSpawner`, the one\n * `Sandbox.hostContext` serves beside the machine's `FileSystem`. The machine\n * needs `sh`, `find`, `xargs`, `tar`, `head`, and `base64`; GNU, BusyBox, and\n * BSD userlands all have them. Output crosses as base64, so a transport whose\n * channel carries only text returns it intact. A search reads at most\n * {@link maxBytes} of file content and refuses beyond that, naming the root\n * to narrow.\n *\n * @since 1.0.0-rc.8\n */\n\nimport type * as ChildProcessSpawner from \"@smthrs/kernel/ChildProcessSpawner\"\nimport * as Path from \"@smthrs/kernel/Path\"\nimport { Context, Effect } from \"effect\"\nimport * as Base64 from \"effect/encoding/Base64\"\nimport * as FileSystem from \"effect/FileSystem\"\nimport * as Result from \"effect/Result\"\nimport * as Exec from \"./internal/Exec.ts\"\nimport * as Prune from \"./internal/Prune.ts\"\nimport * as RemoteTree from \"./internal/RemoteTree.ts\"\nimport * as Tar from \"./internal/Tar.ts\"\nimport * as PortableSearch from \"./PortableSearch.ts\"\nimport * as Search from \"./Search.ts\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * The most file content one search brings back from the machine.\n *\n * The copy is held in memory while the in-process peer reads it, so the\n * bound is on this process's memory rather than on the search: a root that\n * holds more is refused with `response_too_large` and a narrower root or\n * globs answer it.\n *\n * @category constants\n * @since 1.0.0-rc.8\n */\nexport const maxBytes = 256 * 1024 * 1024\n\n/** The most a listing, with its `.gitignore` files, may take. */\nconst maxListingBytes = 64 * 1024 * 1024\n\nconst quoted = (value: string): string => `'${value.replaceAll(\"'\", `'\\\\''`)}'`\n\nconst pruned = `\\\\( ${Prune.repositoryDirectories.map((name) => `-name ${quoted(name)}`).join(\" -o \")} \\\\) -prune`\n\n/** The refusal for a machine without one of the tools a search runs. */\nconst missing = (tool: string) => `searching this machine needs ${tool}, which it does not have`\n\nconst requireTools = `for t in find xargs tar head; do command -v \"$t\" >/dev/null || { ` +\n  `echo \"${missing(\"$t\")}\" >&2; exit 3; }; done`\n\n/**\n * `$1` is the root, `$2` the byte bound, and `$3` is `1` to send the\n * `.gitignore` files after the listing. Records are NUL-terminated `<kind><path>`;\n * an `E` record ends the listing, and a tar stream of the ignore files follows.\n */\nconst listing = [\n  \"set -f\",\n  requireTools,\n  \"r=$1\",\n  \"{\",\n  \"  if [ -d \\\"$r\\\" ]; then if [ -r \\\"$r\\\" ] && [ -x \\\"$r\\\" ]; then printf 'd%s\\\\0' \\\"$r\\\"; else printf 'u%s\\\\0' \\\"$r\\\"; fi\",\n  \"  elif [ -f \\\"$r\\\" ]; then printf 'f%s\\\\0' \\\"$r\\\"\",\n  \"  elif [ -e \\\"$r\\\" ]; then printf 'o%s\\\\0' \\\"$r\\\"\",\n  \"  fi\",\n  // No `-exec \u2026 {} +` inside parentheses: BusyBox `find` never runs one there.\n  `  find -H \"$r\" -mindepth 1 ${pruned} -o -type d -exec printf 'd%s\\\\0' {} + ` +\n  `-o -type f -exec printf 'f%s\\\\0' {} + ` +\n  `-o -type l -exec sh -c 'for p do if [ -d \"$p\" ]; then k=D; elif [ -f \"$p\" ]; then k=F; else k=L; fi; ` +\n  `printf \"%s%s\\\\0\" \"$k\" \"$p\"; done' sh {} + -o -exec printf 'o%s\\\\0' {} + 2>/dev/null`,\n  \"  printf 'E\\\\0'\",\n  `  if [ \"$3\" = 1 ]; then find -H \"$r\" -mindepth 1 ${pruned} -o -type f -name .gitignore -print0 2>/dev/null | ` +\n  \"(cd / && COPYFILE_DISABLE=1 xargs -0 -r tar -cf - -- 2>/dev/null); fi\",\n  \"} | head -c \\\"$2\\\" | base64\"\n].join(\"\\n\")\n\n/** `$1` is the byte bound; standard input is the NUL-terminated absolute paths to send. */\nconst fetching = [\n  requireTools,\n  \"cd / && COPYFILE_DISABLE=1 xargs -0 -r tar -chf - -- 2>/dev/null | head -c \\\"$1\\\" | base64\"\n].join(\"\\n\")\n\nconst failed = (root: string, reason: string): StdError.StdError =>\n  new StdError.StdError({\n    code: \"command_failed\",\n    message: `Could not search ${root} on this machine: ${reason}`,\n    path: root\n  })\n\nconst tooLarge = (root: string, bound: number): StdError.StdError =>\n  new StdError.StdError({\n    code: \"response_too_large\",\n    message: `The files under ${root} come to more than ${bound} bytes; narrow the root or the globs`,\n    path: root\n  })\n\n/**\n * Reads the program from the first line of standard input, as base64, and\n * runs it with the arguments and the rest of standard input. A program in\n * the argv would be quoted once by the spawner and again by the transport,\n * and a sealed host refuses to start a command line past 4,096 characters;\n * this line stays short whatever the program says.\n */\nconst bootstrap = `command -v base64 >/dev/null || { echo \"${missing(\"base64\")}\" >&2; exit 3; }; ` +\n  \"IFS= read -r p && p=$(printf %s \\\"$p\\\" | base64 -d) && exec sh -c \\\"$p\\\" sh \\\"$@\\\"\"\n\n/**\n * Runs one script on the machine and decodes the base64 it prints, refusing\n * output that reached `bound`: `head` cut it, so it is not the whole answer.\n */\nconst run = (\n  root: string,\n  script: string,\n  args: ReadonlyArray<string>,\n  bound: number,\n  stdin = \"\"\n): Effect.Effect<Uint8Array, StdError.StdError, ChildProcessSpawner.ChildProcessSpawner> =>\n  Effect.gen(function*() {\n    const result = yield* Exec.exec(\"sh\", {\n      args: [\"-c\", bootstrap, \"sh\", ...args],\n      stdin: `${Base64.encode(new TextEncoder().encode(script))}\\n${stdin}`\n    }).pipe(Effect.mapError((error) => failed(root, error.message)))\n    if (result.exitCode !== 0) {\n      return yield* Effect.fail(failed(root, result.stderr.trim() || `exit ${result.exitCode}`))\n    }\n    const decoded = Base64.decode(result.stdout.replaceAll(/\\s/g, \"\"))\n    if (Result.isFailure(decoded)) return yield* Effect.fail(failed(root, \"the machine answered with invalid base64\"))\n    if (decoded.success.length >= bound) return yield* Effect.fail(tooLarge(root, bound - 1))\n    return decoded.success\n  })\n\n/**\n * Builds the peer over a machine's spawner and its `Path`, which resolves a\n * relative root where the machine's file operations do. `maxBytes` lowers\n * the bound on the file content one search brings back; the default is\n * {@link maxBytes}.\n *\n * @category constructors\n * @since 1.0.0-rc.8\n */\nexport const make = (\n  services: Context.Context<ChildProcessSpawner.ChildProcessSpawner | Path.Path>,\n  options?: { readonly maxBytes?: number | undefined }\n): Search.Search => {\n  const path = Context.get(services, Path.Path)\n  const contentBound = (options?.maxBytes ?? maxBytes) + 1\n  const copy = (tree: RemoteTree.Tree) =>\n    Context.make(FileSystem.FileSystem, RemoteTree.fileSystem(tree, path)).pipe(Context.add(Path.Path, path))\n  const listed = (root: string, noIgnore: boolean | undefined) => {\n    const resolved = path.resolve(root)\n    const bound = maxListingBytes + 1\n    return Effect.flatMap(\n      run(root, listing, [resolved, String(bound), noIgnore === true ? \"0\" : \"1\"], bound),\n      (bytes) => {\n        const tree = RemoteTree.parse(bytes, resolved, path)\n        return tree === undefined ? Effect.fail(failed(root, \"the listing came back malformed\")) : Effect.succeed(tree)\n      }\n    )\n  }\n  return Search.make({\n    grep: (input) =>\n      Effect.gen(function*() {\n        const tree = yield* listed(input.root, input.noIgnore)\n        const read = yield* PortableSearch.searched(input).pipe(Effect.provide(copy(tree)))\n        const files = [...new Set(read.map((file) => path.resolve(file)))]\n        const bytes = files.length === 0 ? new Uint8Array() : yield* run(\n          input.root,\n          fetching,\n          [String(contentBound)],\n          contentBound,\n          files.map((file) => `${file}\\0`).join(\"\")\n        )\n        // `tar` ends every archive it writes, even one whose files it could not read.\n        const members = files.length === 0 || bytes.length > 0 ? Tar.files(bytes) : undefined\n        if (members === undefined) return yield* Effect.fail(failed(input.root, \"the files came back malformed\"))\n        const contents = new Map([...tree.contents, ...RemoteTree.absolute(members)])\n        return yield* PortableSearch.make(copy({ ...tree, contents })).grep(input)\n      }).pipe(Effect.provide(services)),\n    glob: (input) =>\n      Effect.flatMap(listed(input.root, input.noIgnore), (tree) => PortableSearch.make(copy(tree)).glob(input)).pipe(\n        Effect.provide(services)\n      )\n  })\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/Search.d.ts

@@ -0,0 +1,163 @@
+/**
+ * The implementation seam for the ripgrep search contract.
+ *
+ * Both implementations answer the same normalized calls. `PortableSearch`
+ * performs the work in-process; `NativeSearch` drives the `rg` executable.
+ * Callers select an implementation by Layer and cannot observe which one was
+ * selected from the result.
+ *
+ * @since 1.0.0
+ */
+import { Context, Effect, Layer } from "effect";
+import * as StdError from "./StdError.ts";
+/**
+ * Normalized grep input shared by both implementations.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface GrepInput {
+    readonly pattern: string;
+    readonly root: string;
+    readonly fixedStrings: boolean;
+    readonly ignoreCase: boolean;
+    readonly smartCase: boolean;
+    readonly globs: ReadonlyArray<string>;
+    readonly beforeContext: number;
+    readonly afterContext: number;
+    readonly maxCount?: number | undefined;
+    readonly filesWithMatches: boolean;
+    /** Opt out of root-scoped .gitignore rules; defaults to false. */
+    readonly noIgnore?: boolean | undefined;
+    readonly hidden: boolean;
+    readonly symbols: boolean;
+    readonly limit: number;
+}
+/**
+ * One matching or context line, as a peer produces it before grouping.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface GrepLine {
+    readonly file: string;
+    readonly line: number;
+    readonly text: string;
+    readonly kind: "match" | "context";
+}
+/**
+ * One context line carried inside the match it belongs to.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface ContextLine {
+    readonly line: number;
+    readonly text: string;
+}
+/**
+ * The definition enclosing a hit, when the file's shape says so plainly.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Symbol {
+    readonly kind: string;
+    readonly name: string;
+    readonly startLine: number;
+    readonly endLine: number;
+}
+/**
+ * One hit: the matching line, the context that belongs to it, and the
+ * definition it sits in.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface GrepMatch {
+    readonly file: string;
+    readonly line: number;
+    readonly text: string;
+    readonly before: ReadonlyArray<ContextLine>;
+    readonly after: ReadonlyArray<ContextLine>;
+    readonly symbol?: Symbol | undefined;
+}
+/**
+ * Normalized grep output.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface GrepOutput {
+    readonly matches: ReadonlyArray<GrepMatch>;
+    readonly files: ReadonlyArray<string>;
+    readonly filesSearched: number;
+    readonly skippedBinary: number;
+    readonly truncated: boolean;
+    readonly notice?: string | undefined;
+}
+/**
+ * Normalized glob input.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface GlobInput {
+    readonly pattern: string;
+    readonly root: string;
+    /** Opt out of root-scoped .gitignore rules; defaults to false. */
+    readonly noIgnore?: boolean | undefined;
+    readonly hidden: boolean;
+    readonly limit: number;
+}
+/**
+ * Normalized glob output.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface GlobOutput {
+    readonly paths: ReadonlyArray<string>;
+    readonly total: number;
+    readonly truncated: boolean;
+    readonly notice?: string | undefined;
+}
+/**
+ * The one search contract implemented by native and portable peers.
+ *
+ * @category services
+ * @since 1.0.0
+ */
+export interface Search {
+    readonly grep: (input: GrepInput) => Effect.Effect<GrepOutput, StdError.StdError>;
+    readonly glob: (input: GlobInput) => Effect.Effect<GlobOutput, StdError.StdError>;
+}
+/**
+ * The {@link Search} service tag.
+ *
+ * @category services
+ * @since 1.0.0
+ */
+export declare const Search: Context.Service<Search, Search>;
+/**
+ * Builds a search service from its two operations.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (service: Search) => Search;
+/**
+ * Builds an unavailable search service for compositions that deliberately omit search.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const makeNoop: () => Search;
+/**
+ * Provides {@link makeNoop}.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layerNoop: Layer.Layer<Search>;
+//# sourceMappingURL=Search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Search.d.ts","sourceRoot":"","sources":["../../src/Search.ts"],"names":[],"mappings":"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"}

package/dist/cjs/Search.js

@@ -0,0 +1,51 @@
+"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 Search_exports = {};
+__export(Search_exports, {
+  Search: () => Search,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeNoop: () => makeNoop
+});
+module.exports = __toCommonJS(Search_exports);
+var import_effect = require("effect");
+var StdError = __toESM(require("./StdError.js"), 1);
+const Search = import_effect.Context.Service("@smthrs/std/Search");
+const make = (service) => Search.of(service);
+const makeNoop = () => {
+  const unavailable = () => import_effect.Effect.fail(
+    new StdError.StdError({
+      code: "provider_unavailable",
+      message: "No search implementation is configured"
+    })
+  );
+  return make({ grep: unavailable, glob: unavailable });
+};
+const layerNoop = import_effect.Layer.succeed(Search, makeNoop());
+//# sourceMappingURL=Search.js.map

package/dist/cjs/Search.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Search.ts"],
+  "sourcesContent": ["/**\n * The implementation seam for the ripgrep search contract.\n *\n * Both implementations answer the same normalized calls. `PortableSearch`\n * performs the work in-process; `NativeSearch` drives the `rg` executable.\n * Callers select an implementation by Layer and cannot observe which one was\n * selected from the result.\n *\n * @since 1.0.0\n */\n\nimport { Context, Effect, Layer } from \"effect\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * Normalized grep input shared by both implementations.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface GrepInput {\n  readonly pattern: string\n  readonly root: string\n  readonly fixedStrings: boolean\n  readonly ignoreCase: boolean\n  readonly smartCase: boolean\n  readonly globs: ReadonlyArray<string>\n  readonly beforeContext: number\n  readonly afterContext: number\n  readonly maxCount?: number | undefined\n  readonly filesWithMatches: boolean\n  /** Opt out of root-scoped .gitignore rules; defaults to false. */\n  readonly noIgnore?: boolean | undefined\n  readonly hidden: boolean\n  readonly symbols: boolean\n  readonly limit: number\n}\n\n/**\n * One matching or context line, as a peer produces it before grouping.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface GrepLine {\n  readonly file: string\n  readonly line: number\n  readonly text: string\n  readonly kind: \"match\" | \"context\"\n}\n\n/**\n * One context line carried inside the match it belongs to.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface ContextLine {\n  readonly line: number\n  readonly text: string\n}\n\n/**\n * The definition enclosing a hit, when the file's shape says so plainly.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Symbol {\n  readonly kind: string\n  readonly name: string\n  readonly startLine: number\n  readonly endLine: number\n}\n\n/**\n * One hit: the matching line, the context that belongs to it, and the\n * definition it sits in.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface GrepMatch {\n  readonly file: string\n  readonly line: number\n  readonly text: string\n  readonly before: ReadonlyArray<ContextLine>\n  readonly after: ReadonlyArray<ContextLine>\n  readonly symbol?: Symbol | undefined\n}\n\n/**\n * Normalized grep output.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface GrepOutput {\n  readonly matches: ReadonlyArray<GrepMatch>\n  readonly files: ReadonlyArray<string>\n  readonly filesSearched: number\n  readonly skippedBinary: number\n  readonly truncated: boolean\n  readonly notice?: string | undefined\n}\n\n/**\n * Normalized glob input.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface GlobInput {\n  readonly pattern: string\n  readonly root: string\n  /** Opt out of root-scoped .gitignore rules; defaults to false. */\n  readonly noIgnore?: boolean | undefined\n  readonly hidden: boolean\n  readonly limit: number\n}\n\n/**\n * Normalized glob output.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface GlobOutput {\n  readonly paths: ReadonlyArray<string>\n  readonly total: number\n  readonly truncated: boolean\n  readonly notice?: string | undefined\n}\n\n/**\n * The one search contract implemented by native and portable peers.\n *\n * @category services\n * @since 1.0.0\n */\nexport interface Search {\n  readonly grep: (input: GrepInput) => Effect.Effect<GrepOutput, StdError.StdError>\n  readonly glob: (input: GlobInput) => Effect.Effect<GlobOutput, StdError.StdError>\n}\n\n/**\n * The {@link Search} service tag.\n *\n * @category services\n * @since 1.0.0\n */\nexport const Search: Context.Service<Search, Search> = Context.Service(\"@smthrs/std/Search\")\n\n/**\n * Builds a search service from its two operations.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (service: Search): Search => Search.of(service)\n\n/**\n * Builds an unavailable search service for compositions that deliberately omit search.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const makeNoop = (): Search => {\n  const unavailable = () =>\n    Effect.fail(\n      new StdError.StdError({\n        code: \"provider_unavailable\",\n        message: \"No search implementation is configured\"\n      })\n    )\n  return make({ grep: unavailable, glob: unavailable })\n}\n\n/**\n * Provides {@link makeNoop}.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layerNoop: Layer.Layer<Search> = Layer.succeed(Search, makeNoop())\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,oBAAuC;AACvC,eAA0B;AA2InB,MAAM,SAA0C,sBAAQ,QAAQ,oBAAoB;AAQpF,MAAM,OAAO,CAAC,YAA4B,OAAO,GAAG,OAAO;AAQ3D,MAAM,WAAW,MAAc;AACpC,QAAM,cAAc,MAClB,qBAAO;AAAA,IACL,IAAI,SAAS,SAAS;AAAA,MACpB,MAAM;AAAA,MACN,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AACF,SAAO,KAAK,EAAE,MAAM,aAAa,MAAM,YAAY,CAAC;AACtD;AAQO,MAAM,YAAiC,oBAAM,QAAQ,QAAQ,SAAS,CAAC;",
+  "names": []
+}

package/dist/cjs/SearchConformance.d.ts

@@ -0,0 +1,115 @@
+/**
+ * A differential conformance kit for {@link Search} implementations.
+ *
+ * `Search` is a public extension seam: a host binds its own implementation and
+ * every `grep` and `glob` call in the package goes through it. Two peers ship
+ * here, and the contract they are held to used to live only in
+ * `test/SearchConformance.test.ts` — a file `package.json` does not publish, so
+ * a third-party peer had the seam and no way to prove it filled it. Worse, the
+ * cases there are hand-picked: they pin the divergences somebody already
+ * found. A literal `?` matched `fo` in one peer and `foo?` in the other for as
+ * long as nobody thought to write that case down.
+ *
+ * This module is the other half. It generates a tree and a batch of calls from
+ * a seed, runs them through two implementations, and reports every answer that
+ * differs. Nothing here knows which peer is right: a divergence is the finding,
+ * and the reference peer to compare against is the caller's choice —
+ * `PortableSearch` is the obvious one, because it needs no external binary.
+ *
+ * The generator deliberately stays inside the ground both peers claim to
+ * share: no symlinks, no unreadable directories, no CRLF, no NUL bytes, no
+ * filename a shell would have to quote. Those are the cases the hand-written
+ * table pins one by one, with an expected value that says which behaviour is
+ * intended. A generator cannot say that; it can only say the two disagree.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type * as Search from "./Search.ts";
+/**
+ * One file the generated tree contains.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface GeneratedFile {
+    /** Path relative to the tree root, always with `/` separators. */
+    readonly path: string;
+    readonly content: string;
+}
+/**
+ * A generated tree plus the calls to make against it.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Plan {
+    readonly seed: number;
+    readonly root: string;
+    readonly files: ReadonlyArray<GeneratedFile>;
+    readonly grep: ReadonlyArray<Search.GrepInput>;
+    readonly glob: ReadonlyArray<Search.GlobInput>;
+}
+/**
+ * One call two implementations answered differently.
+ *
+ * `subject` and `reference` are the rendered answers, so a report names the
+ * bytes that differ rather than saying only that they did.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Divergence {
+    readonly call: "grep" | "glob";
+    readonly input: Search.GrepInput | Search.GlobInput;
+    readonly subject: string;
+    readonly reference: string;
+}
+/**
+ * Builds a reproducible tree and call batch from a seed.
+ *
+ * The same seed and root always produce the same plan, so a divergence a run
+ * reports can be replayed exactly by rerunning that seed.
+ *
+ * @category generators
+ * @since 1.0.0
+ */
+export declare const plan: (options: {
+    readonly seed: number;
+    readonly root: string;
+    readonly files?: number | undefined;
+    readonly calls?: number | undefined;
+}) => Plan;
+/**
+ * Writes a plan's tree under its root.
+ *
+ * @category generators
+ * @since 1.0.0
+ */
+export declare const materialize: (target: Plan) => Effect.Effect<void, never, FileSystem.FileSystem | Path.Path>;
+/**
+ * Runs every call in a plan through two implementations and reports the
+ * answers that differ.
+ *
+ * A failure is compared like any other answer: two peers that refuse the same
+ * call with the same code agree, and one that refuses where the other answers
+ * has diverged.
+ *
+ * @category conformance
+ * @since 1.0.0
+ */
+export declare const compare: (options: {
+    readonly plan: Plan;
+    readonly subject: Search.Search;
+    readonly reference: Search.Search;
+}) => Effect.Effect<ReadonlyArray<Divergence>>;
+/**
+ * Renders divergences as the report a failing conformance run should print.
+ *
+ * @category conformance
+ * @since 1.0.0
+ */
+export declare const report: (divergences: ReadonlyArray<Divergence>) => string;
+//# sourceMappingURL=SearchConformance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SearchConformance.d.ts","sourceRoot":"","sources":["../../src/SearchConformance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAG1C;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IAC5C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAC9C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;CAC/C;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAA;IACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAiDD;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC,KAAG,IAyEH,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,QAAQ,IAAI,KACX,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAW3D,CAAA;AAaJ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,GAAI,SAAS;IAC/B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAA;CAClC,KAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,CAcvC,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,aAAa,aAAa,CAAC,UAAU,CAAC,KAAG,MAOhD,CAAA"}

package/dist/cjs/SearchConformance.js

@@ -0,0 +1,172 @@
+"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 SearchConformance_exports = {};
+__export(SearchConformance_exports, {
+  compare: () => compare,
+  materialize: () => materialize,
+  plan: () => plan,
+  report: () => report
+});
+module.exports = __toCommonJS(SearchConformance_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var FileSystem = __toESM(require("effect/FileSystem"), 1);
+var Path = __toESM(require("effect/Path"), 1);
+const random = (seed) => {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = Math.imul(state ^ state >>> 15, 1 | state);
+    value = value + Math.imul(value ^ value >>> 7, 61 | value) ^ value;
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+};
+const pick = (next, values) => values[Math.floor(next() * values.length)];
+const chance = (next, probability) => next() < probability;
+const stems = ["alpha", "beta", "gamma", "Delta", "e-psilon", "ze_ta", "eta2", "th.eta", "iota", "kappa"];
+const extensions = [".ts", ".js", ".txt", ".py", ".md"];
+const directories = ["", "one", "one/two", "three", "three/four/five"];
+const lines = [
+  "needle",
+  "a needle in the line",
+  "Needle capitalised",
+  "no match here",
+  "needle? with a question mark",
+  "a+b and x*y and [z]",
+  "def widen(value):",
+  "class Widget:",
+  "    needle = value",
+  "function widen(value) {",
+  "",
+  "trailing needle"
+];
+const patterns = ["needle", "Needle", "needle?", "a+b", "[z]", "^needle$", "widen", "no match at all"];
+const globPatterns = ["**/*.ts", "*.ts", "**/*", "one/**/*.ts", "**/*.{ts,js}", "**/alpha*"];
+const plan = (options) => {
+  const next = random(options.seed);
+  const fileCount = options.files ?? 12;
+  const callCount = options.calls ?? 12;
+  const files = [];
+  for (let index = 0; index < fileCount; index++) {
+    const directory = pick(next, directories);
+    const name = `${pick(next, stems)}${index}${pick(next, extensions)}`;
+    const path = directory === "" ? name : `${directory}/${name}`;
+    const body = [];
+    for (let line = 0; line < 1 + Math.floor(next() * 8); line++) body.push(pick(next, lines));
+    files.push({ path, content: `${body.join("\n")}${chance(next, 0.8) ? "\n" : ""}` });
+  }
+  if (fileCount > 0) {
+    files.push(
+      { path: ".gitignore", content: "*.ignored\n!keep.ignored\n/root-only.ts\ncache/\n" },
+      { path: "drop.ignored", content: "needle\n" },
+      { path: "keep.ignored", content: "needle\n" },
+      { path: "root-only.ts", content: "needle\n" },
+      { path: "cache/a.ts", content: "needle\n" },
+      { path: "nested/.gitignore", content: "!keep.ignored\n/anchored.ts\nframes/\n" },
+      { path: "nested/keep.ignored", content: "needle\n" },
+      { path: "nested/drop.ignored", content: "needle\n" },
+      { path: "nested/anchored.ts", content: "needle\n" },
+      { path: "nested/deep/anchored.ts", content: "needle\n" },
+      { path: "nested/root-only.ts", content: "needle\n" },
+      { path: "nested/frames/a.ts", content: "needle\n" },
+      { path: "other/frames", content: "needle\n" }
+    );
+  }
+  const roots = [options.root, ...files.map((entry) => `${options.root}/${entry.path}`)];
+  const grep = [];
+  for (let index = 0; index < callCount; index++) {
+    const fixedStrings = chance(next, 0.4);
+    const ignoreCase = chance(next, 0.25);
+    grep.push({
+      pattern: pick(next, patterns),
+      root: chance(next, 0.75) ? options.root : pick(next, roots),
+      fixedStrings,
+      ignoreCase,
+      smartCase: !ignoreCase && chance(next, 0.3),
+      globs: chance(next, 0.4) ? [pick(next, ["*.ts", "*.txt", "!*.js", "**/*.ts"])] : [],
+      beforeContext: Math.floor(next() * 3),
+      afterContext: Math.floor(next() * 3),
+      ...chance(next, 0.3) ? { maxCount: 1 + Math.floor(next() * 2) } : {},
+      filesWithMatches: chance(next, 0.25),
+      hidden: chance(next, 0.5),
+      noIgnore: chance(next, 0.25),
+      symbols: chance(next, 0.3),
+      limit: 1 + Math.floor(next() * 40)
+    });
+  }
+  const glob = [];
+  for (let index = 0; index < callCount; index++) {
+    glob.push({
+      pattern: pick(next, globPatterns),
+      root: options.root,
+      hidden: chance(next, 0.5),
+      noIgnore: chance(next, 0.25),
+      limit: 1 + Math.floor(next() * 20)
+    });
+  }
+  return { seed: options.seed, root: options.root, files, grep, glob };
+};
+const materialize = (target) => Effect.gen(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  yield* Effect.forEach(target.files, (entry) => {
+    const absolute = path.join(target.root, ...entry.path.split("/"));
+    return fileSystem.makeDirectory(path.dirname(absolute), { recursive: true }).pipe(
+      Effect.andThen(fileSystem.writeFileString(absolute, entry.content)),
+      Effect.orDie
+    );
+  }, { discard: true });
+});
+const rendered = (effect) => effect.pipe(
+  Effect.match({
+    onSuccess: (value) => JSON.stringify(value),
+    onFailure: (error) => JSON.stringify({ failure: error.code })
+  })
+);
+const compare = (options) => Effect.gen(function* () {
+  const divergences = [];
+  for (const input of options.plan.grep) {
+    const subject = yield* rendered(options.subject.grep(input));
+    const reference = yield* rendered(options.reference.grep(input));
+    if (subject !== reference) divergences.push({ call: "grep", input, subject, reference });
+  }
+  for (const input of options.plan.glob) {
+    const subject = yield* rendered(options.subject.glob(input));
+    const reference = yield* rendered(options.reference.glob(input));
+    if (subject !== reference) divergences.push({ call: "glob", input, subject, reference });
+  }
+  return divergences;
+});
+const report = (divergences) => divergences.map(
+  (divergence) => [
+    `${divergence.call}(${JSON.stringify(divergence.input)})`,
+    `  subject:   ${divergence.subject}`,
+    `  reference: ${divergence.reference}`
+  ].join("\n")
+).join("\n\n");
+//# sourceMappingURL=SearchConformance.js.map

package/dist/cjs/SearchConformance.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/SearchConformance.ts"],
+  "sourcesContent": ["/**\n * A differential conformance kit for {@link Search} implementations.\n *\n * `Search` is a public extension seam: a host binds its own implementation and\n * every `grep` and `glob` call in the package goes through it. Two peers ship\n * here, and the contract they are held to used to live only in\n * `test/SearchConformance.test.ts` \u2014 a file `package.json` does not publish, so\n * a third-party peer had the seam and no way to prove it filled it. Worse, the\n * cases there are hand-picked: they pin the divergences somebody already\n * found. A literal `?` matched `fo` in one peer and `foo?` in the other for as\n * long as nobody thought to write that case down.\n *\n * This module is the other half. It generates a tree and a batch of calls from\n * a seed, runs them through two implementations, and reports every answer that\n * differs. Nothing here knows which peer is right: a divergence is the finding,\n * and the reference peer to compare against is the caller's choice \u2014\n * `PortableSearch` is the obvious one, because it needs no external binary.\n *\n * The generator deliberately stays inside the ground both peers claim to\n * share: no symlinks, no unreadable directories, no CRLF, no NUL bytes, no\n * filename a shell would have to quote. Those are the cases the hand-written\n * table pins one by one, with an expected value that says which behaviour is\n * intended. A generator cannot say that; it can only say the two disagree.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as FileSystem from \"effect/FileSystem\"\nimport * as Path from \"effect/Path\"\nimport type * as Search from \"./Search.ts\"\nimport type * as StdError from \"./StdError.ts\"\n\n/**\n * One file the generated tree contains.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface GeneratedFile {\n  /** Path relative to the tree root, always with `/` separators. */\n  readonly path: string\n  readonly content: string\n}\n\n/**\n * A generated tree plus the calls to make against it.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Plan {\n  readonly seed: number\n  readonly root: string\n  readonly files: ReadonlyArray<GeneratedFile>\n  readonly grep: ReadonlyArray<Search.GrepInput>\n  readonly glob: ReadonlyArray<Search.GlobInput>\n}\n\n/**\n * One call two implementations answered differently.\n *\n * `subject` and `reference` are the rendered answers, so a report names the\n * bytes that differ rather than saying only that they did.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Divergence {\n  readonly call: \"grep\" | \"glob\"\n  readonly input: Search.GrepInput | Search.GlobInput\n  readonly subject: string\n  readonly reference: string\n}\n\n/**\n * mulberry32: 32 bits of state, uniform enough for fixture generation and\n * reproducible from a seed on every host, which a shared `Math.random` is not.\n */\nconst random = (seed: number): () => number => {\n  let state = seed >>> 0\n  return () => {\n    state = (state + 0x6D2B79F5) >>> 0\n    let value = Math.imul(state ^ (state >>> 15), 1 | state)\n    value = (value + Math.imul(value ^ (value >>> 7), 61 | value)) ^ value\n    return ((value ^ (value >>> 14)) >>> 0) / 4_294_967_296\n  }\n}\n\nconst pick = <A>(next: () => number, values: ReadonlyArray<A>): A => values[Math.floor(next() * values.length)]!\n\nconst chance = (next: () => number, probability: number): boolean => next() < probability\n\n// Names both peers walk identically: no separator, no dot prefix outside the\n// two deliberate hidden entries, no name a directory skip list contains, and\n// no character that would need quoting on a command line.\nconst stems = [\"alpha\", \"beta\", \"gamma\", \"Delta\", \"e-psilon\", \"ze_ta\", \"eta2\", \"th.eta\", \"iota\", \"kappa\"] as const\nconst extensions = [\".ts\", \".js\", \".txt\", \".py\", \".md\"] as const\nconst directories = [\"\", \"one\", \"one/two\", \"three\", \"three/four/five\"] as const\n\n// Lines drawn from a vocabulary that mixes the needle, near misses, regex\n// metacharacters that must survive `fixedStrings`, and definition headers the\n// `symbols` option reads.\nconst lines = [\n  \"needle\",\n  \"a needle in the line\",\n  \"Needle capitalised\",\n  \"no match here\",\n  \"needle? with a question mark\",\n  \"a+b and x*y and [z]\",\n  \"def widen(value):\",\n  \"class Widget:\",\n  \"    needle = value\",\n  \"function widen(value) {\",\n  \"\",\n  \"trailing needle\"\n] as const\n\nconst patterns = [\"needle\", \"Needle\", \"needle?\", \"a+b\", \"[z]\", \"^needle$\", \"widen\", \"no match at all\"] as const\n\nconst globPatterns = [\"**/*.ts\", \"*.ts\", \"**/*\", \"one/**/*.ts\", \"**/*.{ts,js}\", \"**/alpha*\"] as const\n\n/**\n * Builds a reproducible tree and call batch from a seed.\n *\n * The same seed and root always produce the same plan, so a divergence a run\n * reports can be replayed exactly by rerunning that seed.\n *\n * @category generators\n * @since 1.0.0\n */\nexport const plan = (options: {\n  readonly seed: number\n  readonly root: string\n  readonly files?: number | undefined\n  readonly calls?: number | undefined\n}): Plan => {\n  const next = random(options.seed)\n  const fileCount = options.files ?? 12\n  const callCount = options.calls ?? 12\n  const files: Array<GeneratedFile> = []\n  for (let index = 0; index < fileCount; index++) {\n    const directory = pick(next, directories)\n    // The index makes every generated path unique, including repeated random picks.\n    const name = `${pick(next, stems)}${index}${pick(next, extensions)}`\n    const path = directory === \"\" ? name : `${directory}/${name}`\n    const body: Array<string> = []\n    for (let line = 0; line < 1 + Math.floor(next() * 8); line++) body.push(pick(next, lines))\n    files.push({ path, content: `${body.join(\"\\n\")}${chance(next, 0.8) ? \"\\n\" : \"\"}` })\n  }\n\n  // Always exercise precedence, anchoring, directory pruning and nested\n  // negation alongside each seed's generated content (without a git repo).\n  if (fileCount > 0) {\n    files.push(\n      { path: \".gitignore\", content: \"*.ignored\\n!keep.ignored\\n/root-only.ts\\ncache/\\n\" },\n      { path: \"drop.ignored\", content: \"needle\\n\" },\n      { path: \"keep.ignored\", content: \"needle\\n\" },\n      { path: \"root-only.ts\", content: \"needle\\n\" },\n      { path: \"cache/a.ts\", content: \"needle\\n\" },\n      { path: \"nested/.gitignore\", content: \"!keep.ignored\\n/anchored.ts\\nframes/\\n\" },\n      { path: \"nested/keep.ignored\", content: \"needle\\n\" },\n      { path: \"nested/drop.ignored\", content: \"needle\\n\" },\n      { path: \"nested/anchored.ts\", content: \"needle\\n\" },\n      { path: \"nested/deep/anchored.ts\", content: \"needle\\n\" },\n      { path: \"nested/root-only.ts\", content: \"needle\\n\" },\n      { path: \"nested/frames/a.ts\", content: \"needle\\n\" },\n      { path: \"other/frames\", content: \"needle\\n\" }\n    )\n  }\n\n  const roots = [options.root, ...files.map((entry) => `${options.root}/${entry.path}`)]\n  const grep: Array<Search.GrepInput> = []\n  for (let index = 0; index < callCount; index++) {\n    const fixedStrings = chance(next, 0.4)\n    // `Grep.run` refuses `ignoreCase` together with `smartCase` as mutually\n    // exclusive, so a generated call carrying both would be exploring ground\n    // the contract does not describe.\n    const ignoreCase = chance(next, 0.25)\n    grep.push({\n      pattern: pick(next, patterns),\n      root: chance(next, 0.75) ? options.root : pick(next, roots),\n      fixedStrings,\n      ignoreCase,\n      smartCase: !ignoreCase && chance(next, 0.3),\n      globs: chance(next, 0.4) ? [pick(next, [\"*.ts\", \"*.txt\", \"!*.js\", \"**/*.ts\"])] : [],\n      beforeContext: Math.floor(next() * 3),\n      afterContext: Math.floor(next() * 3),\n      ...(chance(next, 0.3) ? { maxCount: 1 + Math.floor(next() * 2) } : {}),\n      filesWithMatches: chance(next, 0.25),\n      hidden: chance(next, 0.5),\n      noIgnore: chance(next, 0.25),\n      symbols: chance(next, 0.3),\n      limit: 1 + Math.floor(next() * 40)\n    })\n  }\n\n  const glob: Array<Search.GlobInput> = []\n  for (let index = 0; index < callCount; index++) {\n    glob.push({\n      pattern: pick(next, globPatterns),\n      root: options.root,\n      hidden: chance(next, 0.5),\n      noIgnore: chance(next, 0.25),\n      limit: 1 + Math.floor(next() * 20)\n    })\n  }\n\n  return { seed: options.seed, root: options.root, files, grep, glob }\n}\n\n/**\n * Writes a plan's tree under its root.\n *\n * @category generators\n * @since 1.0.0\n */\nexport const materialize = (\n  target: Plan\n): Effect.Effect<void, never, FileSystem.FileSystem | Path.Path> =>\n  Effect.gen(function*() {\n    const fileSystem = yield* FileSystem.FileSystem\n    const path = yield* Path.Path\n    yield* Effect.forEach(target.files, (entry) => {\n      const absolute = path.join(target.root, ...entry.path.split(\"/\"))\n      return fileSystem.makeDirectory(path.dirname(absolute), { recursive: true }).pipe(\n        Effect.andThen(fileSystem.writeFileString(absolute, entry.content)),\n        Effect.orDie\n      )\n    }, { discard: true })\n  })\n\n/** A typed answer rendered so two of them can be compared as text. */\nconst rendered = <A>(\n  effect: Effect.Effect<A, StdError.StdError>\n): Effect.Effect<string> =>\n  effect.pipe(\n    Effect.match({\n      onSuccess: (value) => JSON.stringify(value),\n      onFailure: (error) => JSON.stringify({ failure: error.code })\n    })\n  )\n\n/**\n * Runs every call in a plan through two implementations and reports the\n * answers that differ.\n *\n * A failure is compared like any other answer: two peers that refuse the same\n * call with the same code agree, and one that refuses where the other answers\n * has diverged.\n *\n * @category conformance\n * @since 1.0.0\n */\nexport const compare = (options: {\n  readonly plan: Plan\n  readonly subject: Search.Search\n  readonly reference: Search.Search\n}): Effect.Effect<ReadonlyArray<Divergence>> =>\n  Effect.gen(function*() {\n    const divergences: Array<Divergence> = []\n    for (const input of options.plan.grep) {\n      const subject = yield* rendered(options.subject.grep(input))\n      const reference = yield* rendered(options.reference.grep(input))\n      if (subject !== reference) divergences.push({ call: \"grep\", input, subject, reference })\n    }\n    for (const input of options.plan.glob) {\n      const subject = yield* rendered(options.subject.glob(input))\n      const reference = yield* rendered(options.reference.glob(input))\n      if (subject !== reference) divergences.push({ call: \"glob\", input, subject, reference })\n    }\n    return divergences\n  })\n\n/**\n * Renders divergences as the report a failing conformance run should print.\n *\n * @category conformance\n * @since 1.0.0\n */\nexport const report = (divergences: ReadonlyArray<Divergence>): string =>\n  divergences.map((divergence) =>\n    [\n      `${divergence.call}(${JSON.stringify(divergence.input)})`,\n      `  subject:   ${divergence.subject}`,\n      `  reference: ${divergence.reference}`\n    ].join(\"\\n\")\n  ).join(\"\\n\\n\")\n"],
+  "mappings": "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",
+  "names": []
+}