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

package/dist/esm/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/esm/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/esm/Search.js

@@ -0,0 +1,47 @@
+/**
+ * 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.js";
+/**
+ * The {@link Search} service tag.
+ *
+ * @category services
+ * @since 1.0.0
+ */
+export const Search = Context.Service("@smthrs/std/Search");
+/**
+ * Builds a search service from its two operations.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const make = (service) => Search.of(service);
+/**
+ * Builds an unavailable search service for compositions that deliberately omit search.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const makeNoop = () => {
+    const unavailable = () => Effect.fail(new StdError.StdError({
+        code: "provider_unavailable",
+        message: "No search implementation is configured"
+    }));
+    return make({ grep: unavailable, glob: unavailable });
+};
+/**
+ * Provides {@link makeNoop}.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export const layerNoop = Layer.succeed(Search, makeNoop());
+//# sourceMappingURL=Search.js.map

package/dist/esm/Search.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Search.js","sourceRoot":"","sources":["../../src/Search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC/C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAqIzC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAoC,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;AAE5F;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,OAAe,EAAU,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,CAAA;AAEnE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAW,EAAE;IACnC,MAAM,WAAW,GAAG,GAAG,EAAE,CACvB,MAAM,CAAC,IAAI,CACT,IAAI,QAAQ,CAAC,QAAQ,CAAC;QACpB,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,wCAAwC;KAClD,CAAC,CACH,CAAA;IACH,OAAO,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAA;AACvD,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAwB,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAA","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"]}

package/dist/esm/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/esm/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/esm/SearchConformance.js

@@ -0,0 +1,193 @@
+/**
+ * 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";
+/**
+ * mulberry32: 32 bits of state, uniform enough for fixture generation and
+ * reproducible from a seed on every host, which a shared `Math.random` is not.
+ */
+const random = (seed) => {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6D2B79F5) >>> 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) / 4_294_967_296;
+    };
+};
+const pick = (next, values) => values[Math.floor(next() * values.length)];
+const chance = (next, probability) => next() < probability;
+// Names both peers walk identically: no separator, no dot prefix outside the
+// two deliberate hidden entries, no name a directory skip list contains, and
+// no character that would need quoting on a command line.
+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"];
+// Lines drawn from a vocabulary that mixes the needle, near misses, regex
+// metacharacters that must survive `fixedStrings`, and definition headers the
+// `symbols` option reads.
+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*"];
+/**
+ * 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 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);
+        // The index makes every generated path unique, including repeated random picks.
+        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" : ""}` });
+    }
+    // Always exercise precedence, anchoring, directory pruning and nested
+    // negation alongside each seed's generated content (without a git repo).
+    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);
+        // `Grep.run` refuses `ignoreCase` together with `smartCase` as mutually
+        // exclusive, so a generated call carrying both would be exploring ground
+        // the contract does not describe.
+        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 };
+};
+/**
+ * Writes a plan's tree under its root.
+ *
+ * @category generators
+ * @since 1.0.0
+ */
+export 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 });
+});
+/** A typed answer rendered so two of them can be compared as text. */
+const rendered = (effect) => effect.pipe(Effect.match({
+    onSuccess: (value) => JSON.stringify(value),
+    onFailure: (error) => JSON.stringify({ failure: error.code })
+}));
+/**
+ * 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 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;
+});
+/**
+ * Renders divergences as the report a failing conformance run should print.
+ *
+ * @category conformance
+ * @since 1.0.0
+ */
+export 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/esm/SearchConformance.js.map

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