@drkmttr/adhere 0.7.3 → 0.8.0

package/src/wording.ts

@@ -0,0 +1,90 @@
+import { type Example, examplesOf, type Rule } from "#config.ts";
+import type { RuleEntry } from "#rules.ts";
+
+type Word = Example["word"];
+
+/**
+ * A way a rule's wording differs from the README's rule writing tips, which
+ * the eval measured: the rule shows code of both kinds, and its description
+ * says the words its code is under.
+ */
+export type Straying =
+  /** The rule has code under `word`, and its description does not say it. */
+  | { readonly _tag: "Unsaid"; readonly word: Word }
+  /** The rule has code to write, and no example under `word` of code that breaks it. */
+  | { readonly _tag: "Unshown"; readonly word: Word }
+  /** The description says `word`, which belongs to the other kind of rule. */
+  | { readonly _tag: "Mixed"; readonly word: Word };
+
+/** A rule whose wording differs from the tips, with each way it does. */
+export interface Stray {
+  readonly entry: RuleEntry;
+  readonly straying: ReadonlyArray<Straying>;
+}
+
+export const TIPS_URL = "https://github.com/darkmatter/adhere#rule-writing-tips";
+
+/** Whether a description says a word, whole and in any case: "Must" does, "mustard" does not. */
+const says = (description: string, word: Word): boolean =>
+  new RegExp(`\\b${word.replace(" ", "\\s+")}\\b`, "i").test(description);
+
+/**
+ * How one rule strays from the tips. A rule with only code that breaks it
+ * lacks no example: the README keeps that for a rule with no single correct
+ * form to show.
+ */
+export const strayingOf = (rule: Rule): ReadonlyArray<Straying> => {
+  const { good, bad } = examplesOf(rule);
+  const guideline = good?.word === "should" || bad?.word === "should not";
+  const shown = [good, bad].flatMap((example) => (example === undefined ? [] : [example.word]));
+  const unshown: ReadonlyArray<Word> =
+    good !== undefined && bad === undefined ? [guideline ? "should not" : "never"] : [];
+  // "should" also finds "should not", so a requirement is checked for the one word.
+  const others: ReadonlyArray<Word> = guideline ? ["must", "never"] : ["should"];
+  return [
+    ...shown
+      .filter((word) => !says(rule.description, word))
+      .map((word): Straying => ({ _tag: "Unsaid", word })),
+    ...unshown.map((word): Straying => ({ _tag: "Unshown", word })),
+    ...others
+      .filter((word) => says(rule.description, word))
+      .map((word): Straying => ({ _tag: "Mixed", word })),
+  ];
+};
+
+/** The rules that stray, in the order given. */
+export const straysAmong = (entries: ReadonlyArray<RuleEntry>): ReadonlyArray<Stray> =>
+  entries.flatMap((entry) => {
+    const straying = strayingOf(entry.rule);
+    return straying.length === 0 ? [] : [{ entry, straying }];
+  });
+
+/** One way a rule strays, as a sentence. */
+const sentenceOf = (straying: Straying): string => {
+  switch (straying._tag) {
+    case "Unsaid":
+      return `The description does not say "${straying.word}", though the rule has a ${straying.word} example.`;
+    case "Unshown":
+      return `The rule has no ${straying.word} example. Rules with one example of each kind judge best.`;
+    case "Mixed":
+      return straying.word === "should"
+        ? `The description says "should", a guideline's word, but the rule is a requirement.`
+        : `The description says "${straying.word}", a requirement's word, but the rule is a guideline.`;
+  }
+};
+
+const displayPath = (file: string, root: string): string =>
+  file.startsWith(`${root}/`) ? file.slice(root.length + 1) : file;
+
+/** The wording part of `adhere validate`'s report: each rule that strays, then how. */
+export const formatStrays = (strays: ReadonlyArray<Stray>, root: string): ReadonlyArray<string> =>
+  strays.length === 0
+    ? ["Every rule is worded as the rule writing tips recommend."]
+    : [
+        `${strays.length} ${strays.length === 1 ? "rule is" : "rules are"} not worded as the rule writing tips recommend:`,
+        ...strays.flatMap(({ entry, straying }) => [
+          `  ${entry.id}${entry.file === undefined ? "" : ` (${displayPath(entry.file, root)})`}`,
+          ...straying.map((one) => `    ${sentenceOf(one)}`),
+        ]),
+        `Rule writing tips: ${TIPS_URL}`,
+      ];

package/src/workflows/audit.ts

@@ -1,19 +1,24 @@
 import { type Examples, examplesOf, type Rule, type RuleId } from "#config.ts";
+import { type Excerpt, excerptOf } from "#excerpt.ts";
 import type { ScannedFile, WalkUnavailable } from "#models/Audit.ts";
 import { AdhereConfig } from "#services/AdhereConfig.ts";
-import { AuditCache, type Judgment, sha256 } from "#services/AuditCache.ts";
+import { AuditCache, answersOf, type Judgment, sha256, type Tally } from "#services/AuditCache.ts";
 import {
   fits,
   Jev,
   JevUnavailable,
+  type Judged,
   judgeQuestion,
   judgeRequests,
+  linterQuestion,
   locateRequests,
-  snippetOf,
+  questionRoom,
+  tokensOf,
 } from "#services/Jev.ts";
 import { SourceWalker } from "#services/SourceWalker.ts";
+import { SAMPLE, tallyKeyOf } from "#mechanical.ts";
 import { applicableRules } from "#rules.ts";
-import { type Crypto, Effect, Record } from "effect";
+import { type Crypto, Duration, Effect, Record, Result, Semaphore } from "effect";
 
 export interface Finding {
   readonly rule: RuleId;
@@ -21,7 +26,8 @@ export interface Finding {
   readonly examples: Examples;
   readonly file: string;
   readonly line: number;
-  readonly snippet: string;
+  /** The code around `line` the report shows. */
+  readonly excerpt: Excerpt;
   readonly probability: number;
 }
 
@@ -82,6 +88,8 @@ export interface FilePlan {
   readonly pending: Readonly<Record<RuleId, PreparedRule>>;
   /** Pending checks `--limit` leaves for a later run. */
   readonly deferred: number;
+  /** Pending rules whose linter check question rides along on this file, each with its tally's key. */
+  readonly sampled: Readonly<Record<RuleId, string>>;
 }
 
 /** A run worked out from the files, the rules, and the cache, before any request. */
@@ -168,6 +176,7 @@ export const planAudit = (
       const rules = configuredRules(file.path);
       // Too long for Jev's context: skipped and counted, rather than refused mid-run.
       if (!fits(file.lines, rules)) {
+        yield* Effect.logTrace(`plan ${file.path}: too long for Jev's context, skipped`);
         return {
           file,
           skipped: true,
@@ -176,6 +185,7 @@ export const planAudit = (
           kept: {},
           pending: {},
           deferred: 0,
+          sampled: {},
         } satisfies FilePlan;
       }
       const prepared: Record<RuleId, PreparedRule> = yield* Effect.forEach(
@@ -188,13 +198,15 @@ export const planAudit = (
           ),
       ).pipe(Effect.map(Record.fromEntries));
       const hash = yield* sha256(file.lines.join("\n"));
-      const entry = yield* cache.get(file.path);
-      const remembered = entry?.hash === hash ? entry.judgments : {};
-      const kept = Record.filter(
-        remembered,
-        (judgment, id) => judgment.fingerprint === prepared[id]?.fingerprint,
-      );
+      const answers = yield* cache.get(hash, file.path);
+      const kept: Record<RuleId, Judgment> = Record.filterMap(prepared, ({ fingerprint }) => {
+        const answer = answers[fingerprint];
+        return answer === undefined ? Result.failVoid : Result.succeed({ fingerprint, ...answer });
+      });
       const pending = Record.filter(prepared, (_, id) => kept[id] === undefined);
+      yield* Effect.logTrace(
+        `plan ${file.path}: ${sizeOf(prepared)} rules, ${sizeOf(kept)} cached, ${sizeOf(pending)} to judge`,
+      );
       return {
         file,
         skipped: false,
@@ -203,15 +215,78 @@ export const planAudit = (
         kept,
         pending,
         deferred: 0,
+        sampled: {},
       } satisfies FilePlan;
     });
 
+    // Preset rules are not the project's to change, so the linter check leaves them out.
+    const presetRules = new Set(
+      (config.scopedRules ?? []).flatMap((entry) =>
+        entry.preset === undefined ? [] : [entry.rule],
+      ),
+    );
+
+    /**
+     * The linter check's samples: for each project rule its tally still needs
+     * answers for, files this run judges it on, spread evenly over them in path
+     * order, skipping files the tally has and files its question would not fit.
+     */
+    const withSamples = Effect.fn("audit.samples")(function* (plans: ReadonlyArray<FilePlan>) {
+      const needs = new Map<Rule, { readonly key: string; readonly tallied: Tally["files"] }>();
+      for (const plan of plans) {
+        for (const { rule } of Object.values(plan.pending)) {
+          if (presetRules.has(rule) || needs.has(rule)) continue;
+          const key = yield* tallyKeyOf(config.model, rule);
+          needs.set(rule, { key, tallied: (yield* cache.tally(key))?.files ?? {} });
+        }
+      }
+      for (const [rule, { tallied }] of needs) {
+        if (Object.keys(tallied).length >= SAMPLE) needs.delete(rule);
+      }
+      if (needs.size === 0) return plans;
+
+      const candidates = new Map<Rule, Array<{ readonly plan: FilePlan; readonly id: RuleId }>>();
+      const tokens = new Map<Rule, number>();
+      for (const plan of plans) {
+        let room: number | undefined;
+        for (const [id, { rule }] of Object.entries(plan.pending)) {
+          const need = needs.get(rule);
+          if (need === undefined || need.tallied[plan.file.path] !== undefined) continue;
+          room ??= questionRoom(plan.file.lines);
+          const size = tokens.get(rule) ?? tokensOf(linterQuestion(rule));
+          tokens.set(rule, size);
+          if (size > room) continue;
+          const found = candidates.get(rule);
+          if (found === undefined) candidates.set(rule, [{ plan, id }]);
+          else found.push({ plan, id });
+        }
+      }
+
+      const sampled = new Map<FilePlan, Record<RuleId, string>>();
+      for (const [rule, found] of candidates) {
+        const need = needs.get(rule);
+        if (need === undefined) continue;
+        const count = Math.min(found.length, SAMPLE - Object.keys(need.tallied).length);
+        for (let index = 0; index < count; index++) {
+          const pick = found[Math.floor((index * found.length) / count)];
+          if (pick !== undefined) {
+            sampled.set(pick.plan, { ...sampled.get(pick.plan), [pick.id]: need.key });
+          }
+        }
+      }
+      return plans.map((plan) => {
+        const some = sampled.get(plan);
+        return some === undefined ? plan : { ...plan, sampled: some };
+      });
+    });
+
     const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
     const everything: ReadonlyArray<FilePlan> = yield* Effect.forEach(sorted, planFile, {
       concurrency: 8,
     });
-    const planned =
+    const limited =
       options.limit === undefined ? everything : withinLimit(everything, options.limit);
+    const planned = yield* withSamples(limited);
     const judged = planned.filter((plan) => !plan.skipped);
     const total = (count: (plan: FilePlan) => number) =>
       judged.reduce((sum, plan) => sum + count(plan), 0);
@@ -223,7 +298,9 @@ export const planAudit = (
       skipped: planned.length - judged.length,
       deferred: total((plan) => plan.deferred),
       requests: total((plan) =>
-        isEmpty(plan.pending) ? 0 : judgeRequests(plan.file.lines, rulesOf(plan.pending)),
+        isEmpty(plan.pending)
+          ? 0
+          : judgeRequests(plan.file.lines, rulesOf(plan.pending), Object.keys(plan.sampled)),
       ),
     };
   });
@@ -239,6 +316,29 @@ export const executeAudit = (
   Effect.gen(function* () {
     const jev = yield* Jev;
     const cache = yield* AuditCache;
+    // Files finish together; each tally is read, extended, and written back by one file at a time.
+    const tallying = yield* Semaphore.make(1);
+
+    /** Adds one file's linter check answers to their rules' tallies. */
+    const record = (
+      file: string,
+      sampled: Readonly<Record<RuleId, string>>,
+      linter: Readonly<Record<RuleId, number>>,
+    ) =>
+      tallying.withPermits(1)(
+        Effect.forEach(
+          Object.entries(linter),
+          ([id, probability]) => {
+            const key = sampled[id];
+            return key === undefined
+              ? Effect.void
+              : Effect.flatMap(cache.tally(key), (tally) =>
+                  cache.putTally(key, { files: { ...tally?.files, [file]: probability } }),
+                );
+          },
+          { discard: true },
+        ),
+      );
 
     /** Judges and locates one file the plan left pending, with the requests that took. */
     const judgeFile = Effect.fn("audit.judgeFile")(function* ({
@@ -248,10 +348,12 @@ export const executeAudit = (
       kept,
       pending,
       deferred,
+      sampled,
     }: FilePlan) {
-      const probabilities = isEmpty(pending)
-        ? {}
-        : yield* jev.judge(file.lines, rulesOf(pending)).pipe(inFile(file));
+      const { probabilities, linter }: Judged = isEmpty(pending)
+        ? { probabilities: {}, linter: {} }
+        : yield* jev.judge(file.lines, rulesOf(pending), Object.keys(sampled)).pipe(inFile(file));
+      if (!isEmpty(linter)) yield* record(file.path, sampled, linter);
       const judged: Record<RuleId, Judgment> = { ...kept };
       for (const [id, probability] of Object.entries(probabilities)) {
         const k = pending[id];
@@ -284,13 +386,11 @@ export const executeAudit = (
           );
       const located = Record.map(judged, (judgment, id) => {
         const line = lines[id];
-        return line === undefined
-          ? judgment
-          : { ...judgment, line, snippet: snippetOf(file.lines[line - 1] ?? "") };
+        return line === undefined ? judgment : { ...judgment, line };
       });
 
       const cached = isEmpty(pending) && isEmpty(flagged);
-      if (!cached) yield* cache.put(file.path, { hash, judgments: located });
+      if (!cached) yield* cache.put(hash, answersOf(located));
 
       const findings = Object.entries(located)
         .flatMap(([id, judgment]): ReadonlyArray<Finding> => {
@@ -305,7 +405,7 @@ export const executeAudit = (
                   examples: examplesOf(k.rule),
                   file: file.path,
                   line: judgment.line,
-                  snippet: judgment.snippet ?? "",
+                  excerpt: excerptOf(file.lines, judgment.line),
                   probability: judgment.probability,
                 },
               ]
@@ -318,20 +418,26 @@ export const executeAudit = (
             ? fileResult(cached ? (deferred > 0 ? "waiting" : "cached") : "judged", findings)
             : { status: "blocked", findings, blocked },
         requests:
-          (isEmpty(pending) ? 0 : judgeRequests(file.lines, rulesOf(pending))) +
+          (isEmpty(pending)
+            ? 0
+            : judgeRequests(file.lines, rulesOf(pending), Object.keys(sampled))) +
           (isEmpty(flagged) ? 0 : locateRequests(file.lines, rulesOf(flagged))),
       };
     });
 
     const auditFile = Effect.fn("audit.file")(function* (plan: FilePlan) {
-      const { result, requests } = plan.skipped
-        ? { result: fileResult("skipped", []), requests: 0 }
-        : yield* judgeFile(plan).pipe(
+      const judging = plan.skipped
+        ? Effect.succeed({ result: fileResult("skipped", []), requests: 0 })
+        : judgeFile(plan).pipe(
             // Jev counted more than `fits` estimated. Its count decides: skipped the same way.
             Effect.catchTag("JevOverflow", () =>
               Effect.succeed({
                 result: fileResult("skipped", []),
-                requests: judgeRequests(plan.file.lines, rulesOf(plan.pending)),
+                requests: judgeRequests(
+                  plan.file.lines,
+                  rulesOf(plan.pending),
+                  Object.keys(plan.sampled),
+                ),
               }),
             ),
             // The firewall refuses this file's code every time; the rest of the run goes on.
@@ -342,10 +448,25 @@ export const executeAudit = (
                   findings: [],
                   blocked: { file: plan.file.path, ray },
                 } satisfies FileResult,
-                requests: judgeRequests(plan.file.lines, rulesOf(plan.pending)),
+                requests: judgeRequests(
+                  plan.file.lines,
+                  rulesOf(plan.pending),
+                  Object.keys(plan.sampled),
+                ),
               }),
             ),
           );
+      // Everything logged while judging a file, requests included, names the file.
+      // A file that sent nothing, whether cached or too long, is a trace line: a
+      // large repo's cache would otherwise bury the requests.
+      const [, { result, requests }] = yield* Effect.timed(judging).pipe(
+        Effect.tap(([elapsed, { result, requests }]) =>
+          (requests > 0 ? Effect.logDebug : Effect.logTrace)(
+            `${result.status}: ${requests} ${requests === 1 ? "request" : "requests"}, ${result.findings.length} ${result.findings.length === 1 ? "finding" : "findings"}, ${Math.round(Duration.toMillis(elapsed))} ms`,
+          ),
+        ),
+        Effect.annotateLogs("file", plan.file.path),
+      );
       yield* progress({ requests, findings: result.findings.length });
       return result;
     });
@@ -364,6 +485,28 @@ export const executeAudit = (
     };
   });
 
+/**
+ * Deletes from the cache what the files and rules of a run no longer need:
+ * answers about content no file has, answers to rule texts no rule asks, and
+ * tallies of rules gone. Only after a run that read every file; a run narrowed
+ * by `--filter` cannot tell what the files it left out need.
+ */
+export const pruneCache = Effect.fn("audit.prune")(function* (plan: AuditPlan) {
+  const config = yield* AdhereConfig;
+  const cache = yield* AuditCache;
+  const read = plan.files.filter((file) => !file.skipped);
+  const prepared = read.flatMap((file) => Object.values(file.prepared));
+  const tallies = yield* Effect.forEach(new Set(prepared.map(({ rule }) => rule)), (rule) =>
+    tallyKeyOf(config.model, rule),
+  );
+  const deleted = yield* cache.prune({
+    hashes: new Set(read.map((file) => file.hash)),
+    fingerprints: new Set(prepared.map(({ fingerprint }) => fingerprint)),
+    tallies: new Set(tallies),
+  });
+  yield* Effect.logDebug(`cache pruned: ${deleted} ${deleted === 1 ? "file" : "files"} deleted`);
+});
+
 /** Plans the run and executes it, without asking and without a counter. */
 export const runAudit: Effect.Effect<
   AuditResult,

package/src/workflows/format.ts

@@ -28,18 +28,19 @@ type Line = ReadonlyArray<Span>;
  * palette (`38;5;N`) or truecolor (`38;2;R;G;B`), bold with a trailing `;1`,
  * and a dim line number. Of the header, only the `×` and the rule are red,
  * since a whole line of red is hard to read: the probability is an accent, and
- * the description a soft white. The code's are the terminal's own colors
- * (`3N`), so the user's theme picks shades that read on its background; none
- * is magenta, which would run into the label.
+ * the description a cool near-white, set here since a theme's own white can
+ * be gray. The code's are the terminal's own colors (`3N`), so the user's
+ * theme picks shades that read on its background; none is magenta, which
+ * would run into the underline.
  */
 const THEME: Readonly<Record<Role, string>> = {
-  error: "38;5;197;1",
-  probability: "38;2;250;179;135",
-  description: "38;2;242;205;205",
+  error: "38;2;164;20;71;1",
+  probability: "38;5;156",
+  description: "38;2;230;230;255",
   path: "38;2;5;125;160;1",
   lineNumber: "2",
   underline: "38;2;255;0;175",
-  label: "38;5;212",
+  label: "38;2;242;205;205",
   comment: "2",
   string: "32",
   constant: "33",
@@ -97,17 +98,33 @@ const header = (finding: Finding): Line => [
   span(finding.description, "description"),
 ];
 
-/** The path, the offending line numbered in the gutter, and an underline as long as the line. */
+/**
+ * The path, then the finding's excerpt with each line numbered in the gutter,
+ * and an underline under the offending line's code.
+ */
 const excerpt = (finding: Finding, root: string | undefined): ReadonlyArray<Line> => {
-  const number = String(finding.line);
-  const gutter = span(" ".repeat(number.length + 2));
-  // A snippet is one line: `snippetOf` trims it out of the file.
-  const [code = []] = highlighted(finding.snippet);
-  const underline = "─".repeat(Math.max(1, finding.snippet.trim().length));
+  const { start, lines } = finding.excerpt;
+  const width = String(start + lines.length - 1).length;
+  const gutter = span(" ".repeat(width + 2));
+  const offending = lines[finding.line - start] ?? "";
+  // The line's own indentation, tabs and all, lines the underline up under its code.
+  const indent = offending.slice(0, offending.length - offending.trimStart().length);
+  const underline = "─".repeat(Math.max(1, offending.trim().length));
+  const location = `:${finding.line}:${indent.length + 1}]`;
   return [
-    [gutter, span("╭─["), span(displayPath(finding.file, root), "path"), span(`:${number}:1]`)],
-    [span(" "), span(number, "lineNumber"), span(" │ "), ...code],
-    [gutter, span("· "), span(underline, "underline")],
+    [gutter, span("╭─["), span(displayPath(finding.file, root), "path"), span(location)],
+    ...highlighted(lines.join("\n")).flatMap((code, index): ReadonlyArray<Line> => {
+      const number = String(start + index);
+      const numbered = [
+        span(" ".repeat(width - number.length + 1)),
+        span(number, "lineNumber"),
+        span(" │ "),
+        ...code,
+      ];
+      return start + index === finding.line
+        ? [numbered, [gutter, span("· "), span(indent), span(underline, "underline")]]
+        : [numbered];
+    }),
     [gutter, span("╰────")],
   ];
 };
@@ -125,8 +142,8 @@ const hint = (finding: Finding): ReadonlyArray<Line> => {
 
 /**
  * One diagnostic, in the frame `vp lint` prints on a terminal: a header with
- * the rule in red, the offending line, a pink underline, and the code to write
- * as the hint.
+ * the rule in red, the code around the offending line, a pink underline under
+ * it, and the code to write as the hint.
  */
 const frame = (finding: Finding, root: string | undefined): ReadonlyArray<Line> => [
   header(finding),

package/presets/effect/basics/fn-for-named-effects.md

@@ -1,19 +0,0 @@
----
-description: A named function that returns an Effect must be defined with Effect.fn so the call site is traced. An Effect held in a constant, such as `const program = Effect.gen(...)`, is not a function and is not in scope.
----
-
-```ts must
-const processUser = Effect.fn("processUser")(function* (userId: string) {
-  yield* Effect.logInfo(`Processing user ${userId}`);
-  const user = yield* getUser(userId);
-  return yield* processData(user);
-});
-```
-
-```ts never
-const loadUser = (id: string) =>
-  Effect.gen(function* () {
-    const repo = yield* UserRepo;
-    return yield* repo.find(id);
-  });
-```

package/presets/effect/data/decode-json-with-schema.md

@@ -1,18 +0,0 @@
----
-description: JSON crossing a boundary must be decoded with Schema.fromJsonString, never with JSON.parse followed by a cast.
----
-
-```ts must
-const MoveFromJson = Schema.fromJsonString(Move);
-
-const program = Effect.gen(function* () {
-  const jsonString = '{"from":{"row":"A","column":"1"},"to":{"row":"B","column":"2"}}';
-  const move = yield* Schema.decodeUnknownEffect(MoveFromJson)(jsonString);
-  const json = yield* Schema.encodeEffect(MoveFromJson)(move);
-  return json;
-});
-```
-
-```ts never
-const settings = JSON.parse(text) as Settings;
-```

package/presets/effect/errors/domain-errors-are-tagged.md

@@ -1,19 +0,0 @@
----
-description: A domain failure must be a Schema.TaggedError with its own tag, never a bare Error or a plain object.
----
-
-```ts must
-class ValidationError extends Schema.TaggedError<ValidationError>()("ValidationError", {
-  field: Schema.String,
-  message: Schema.String,
-}) {}
-
-class NotFoundError extends Schema.TaggedError<NotFoundError>()("NotFoundError", {
-  resource: Schema.String,
-  id: Schema.String,
-}) {}
-```
-
-```ts never
-return yield* Effect.fail(new Error("Card declined"));
-```

package/presets/effect/platform/os-access-through-platform-services.md

@@ -1,26 +0,0 @@
----
-description: File, path, process, terminal, and HTTP access must go through Effect's platform services (FileSystem, Path, ChildProcess, Terminal, HttpClient, KeyValueStore), acquired with yield*, never through node: builtins, Bun globals, or fetch. The Bun implementations must be provided once at the entry point with BunServices.layer.
----
-
-```ts must
-import { Effect, FileSystem, Path } from "effect";
-import { HttpClient, HttpClientResponse } from "effect/unstable/http";
-import { BunRuntime, BunServices } from "@effect/platform-bun";
-
-const program = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const config = yield* fs.readFileString(path.join(path.resolve(), "config.json"));
-  const response = yield* HttpClient.get("https://api.example.com/users");
-  const users = yield* HttpClientResponse.schemaBodyJson(Users)(response);
-  return { config, users };
-});
-
-program.pipe(Effect.provide(BunServices.layer), BunRuntime.runMain);
-```
-
-```ts never
-import { readFileSync } from "node:fs";
-
-const settings = readFileSync("settings.json", "utf8");
-```

package/presets/effect/services/methods-have-no-requirements.md

@@ -1,20 +0,0 @@
----
-description: Service method signatures must have no requirements. Dependencies must be acquired inside the layer, never declared on the method.
----
-
-```ts must
-class Database extends Context.Service<
-  Database,
-  {
-    readonly query: (sql: string) => Effect.Effect<unknown[]>;
-    readonly execute: (sql: string) => Effect.Effect<void>;
-  }
->()("@app/Database") {}
-```
-
-```ts never
-class Orders extends Context.Service<
-  Orders,
-  { readonly save: (order: Order) => Effect.Effect<void, SaveError, Database> }
->()("@app/Orders") {}
-```

package/presets/effect/services/provide-at-entry.md

@@ -1,23 +0,0 @@
----
-description: Layers must be provided once at the program entry. A module that is not an entry point must never call Effect.provide.
----
-
-```ts must
-const appLayer = userServiceLayer.pipe(
-  Layer.provideMerge(databaseLayer),
-  Layer.provideMerge(loggerLayer),
-  Layer.provideMerge(configLayer),
-);
-
-const program = Effect.gen(function* () {
-  const users = yield* UserService;
-  yield* users.getUser();
-});
-
-const main = program.pipe(Effect.provide(appLayer));
-```
-
-```ts never
-export const getUser = (id: string) =>
-  UserRepo.find(id).pipe(Effect.provide(UserRepo.layer));
-```

package/presets/effect/testing/test-random.md

@@ -1,22 +0,0 @@
----
-description: A test that depends on randomness must control it with a fixed seed through Random.withSeed, never with Math.random or an unseeded Random.
----
-
-```ts must
-const program = Effect.gen(function* () {
-  const value1 = yield* Random.next;
-  const value2 = yield* Random.next;
-  return [value1, value2];
-});
-
-await Effect.runPromise(
-  Effect.all([program.pipe(Random.withSeed("my-seed")), program.pipe(Random.withSeed("my-seed"))]),
-); // => [[0.018368576514773527, 0.4010840628128671], [0.018368576514773527, 0.4010840628128671]]
-```
-
-```ts never
-it("creates unique ids", () => {
-  const id = Math.random().toString(36).slice(2);
-  expect(id).toHaveLength(11);
-});
-```