@prestack/thread 0.0.2 → 0.1.0

package/dist/integrity/generators/publish.ts

@@ -1,8 +1,10 @@
 import { spawnSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync } from '../../core/files.ts'
+import { valuesIn } from '../../core/rows.ts'
 import { join } from 'node:path'
 import { argv, env, execPath, stderr, stdout } from 'node:process'
 import { pathToFileURL } from 'node:url'
+import { TYPED } from '../../core/answers.ts'
 import { CLI, exit } from '../../core/invoked.ts'
 import { named } from '../../core/scope.ts'
 import { findTree, inTree } from '../../core/tree.ts'
@@ -36,11 +38,6 @@ const CHECKS: readonly Check[] = [
     runs: 'pnpm exec eslint .',
     because: 'the rules that live on the lint surface, which is the only one carrying a fixer the sweep can report but not repair',
   },
-  {
-    id: 'seal',
-    runs: 'pnpm seal:check',
-    because: 'the package must be the bytes it says it is. CHECKED and never regenerated, because a release that rewrites its own seal can never fail it',
-  },
 ]
 
 const MINE = /^(?:npx |pnpm )?thread /
@@ -93,7 +90,7 @@ const PRODUCTION = 'production'
 const secrets = inTree(TREE, 'secrets.ts')
 
 const declared = existsSync(secrets)
-  ? (((await import(pathToFileURL(secrets).href)) as { SECRETS?: readonly Secret[] }).SECRETS ?? [])
+  ? ((valuesIn(readFileSync(secrets)) as { SECRETS?: readonly Secret[] }).SECRETS ?? [])
   : []
 
 const vaulted = declared.some((one) => one.id === TOKEN)
@@ -132,14 +129,14 @@ stdout.write(
 
 stdout.write('publish: deriving and building what the packaging rows state first, so every check below reads the files this release ships rather than the source they were written from.\n')
 
-const made = run('npx thread packaged --build')
+const made = run(`${TYPED} packaged --build`)
 stdout.write(`publish: packaged exited ${String(made)}\n`)
 if (made !== 0) {
   refuse(
     'packaged',
     made,
     'a package whose manifest and release note are not what its rows state would go out describing itself as something nobody declared, and one that did not compile would go out promising files it does not have',
-    'npx thread packaged --build',
+    `${TYPED} packaged --build`,
   )
 }
 
@@ -155,14 +152,14 @@ for (const [index, check] of CHECKS.entries()) {
   if (code !== 0) refuse(check.id, code, check.because, check.runs)
 }
 
-const numbered = run('npx thread packaged --release')
+const numbered = run(`${TYPED} packaged --release`)
 stdout.write(`publish: packaged --release exited ${String(numbered)}\n`)
 if (numbered !== 0) {
   refuse(
     'packaged',
     numbered,
     'the next release number is written onto the manifests only once every check has passed, and writing it refused, so nothing here carries a number to go out under',
-    'npx thread packaged --release',
+    `${TYPED} packaged --release`,
   )
 }
 
@@ -174,19 +171,19 @@ const sent = run(`pnpm -r publish --registry ${registry} --no-git-checks --acces
 
 if (sent !== 0) {
   stderr.write(`\npublish: the checks passed and the publish itself exited ${String(sent)}.\n`)
-  const back = run('npx thread packaged')
+  const back = run(`${TYPED} packaged`)
   stderr.write(
     back === 0
       ? 'publish: the manifests carry the last recorded release again and no note was written, so the next `thread publish` numbers this release once more.\n'
-      : 'publish: the manifests still carry the number that did not go out. Run `npx thread packaged` to put the last recorded release back.\n',
+      : `publish: the manifests still carry the number that did not go out. Run \`${TYPED} packaged\` to put the last recorded release back.\n`,
   )
   exit(1)
 }
 
-const recorded = run('npx thread packaged --record')
+const recorded = run(`${TYPED} packaged --record`)
 stdout.write(`publish: packaged --record exited ${String(recorded)}\n`)
 if (recorded !== 0) {
-  stderr.write('\npublish: the packages went out and the note recording them refused to be written, so the next publish would number this release again. Run `npx thread packaged --record` and read what it says.\n')
+  stderr.write(`\npublish: the packages went out and the note recording them refused to be written, so the next publish would number this release again. Run \`${TYPED} packaged --record\` and read what it says.\n`)
   exit(1)
 }
 
@@ -200,7 +197,7 @@ interface Packaged {
 const sheet = inTree(TREE, SHEET)
 
 const stated = existsSync(sheet)
-  ? ((await import(pathToFileURL(sheet).href)) as { PACKAGES?: readonly Packaged[] })
+  ? (valuesIn(readFileSync(sheet)) as { PACKAGES?: readonly Packaged[] })
   : {}
 
 const shipped = stated.PACKAGES ?? []
@@ -243,5 +240,5 @@ if (asked(['rev-parse', '--is-inside-work-tree']) !== 'true') {
   }
 }
 
-stdout.write(`\npublish: done. What went out was derived, then built, then passed the gate, the lint and the seal, in that order. The compile inside \`thread packaged --build\` is the typecheck.\n`)
+stdout.write(`\npublish: done. What went out was derived, then built, then passed the gate and the lint, in that order. The compile inside \`thread packaged --build\` is the typecheck.\n`)
 exit(0)

package/dist/integrity/generators/trial.d.ts

@@ -1,6 +1,6 @@
 import type { Rule } from 'eslint';
-import type { Constraint } from '../constraint.ts';
-import { type Byproduct, type Slopnator, type Sourced } from '../slopnator.ts';
+import type { Constraint, Sourced } from '../constraint.ts';
+import { type Byproduct, type Slopnator } from '../slopnator.ts';
 export declare const TRIALS_PATH: string;
 export interface Scenario {
     readonly files: readonly Sourced[];

package/dist/integrity/generators/trial.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import * as disk from 'node:fs';
+import { answeredBy, existsSync, readFileSync } from "../../core/files.js";
+import { basename, dirname, join, resolve } from 'node:path';
 import { exit, invoked } from "../../core/invoked.js";
 import { Linter } from 'eslint';
 const TREE = findTree();
@@ -16,8 +17,9 @@ const WRAPPINGS = [
     (source) => `const _probe = () => { ${source} }`,
     (source) => `const _probe = <Probe>{${source}}</Probe>`,
 ];
+const canonical = (at) => at.replace(/^threads\//, `${TREE.name}/`);
 export function probeAt(rule) {
-    const path = rule.where.paths[0] ?? 'src/';
+    const path = canonical(rule.where.paths[0] ?? 'src/');
     if (path === '.')
         return PROBE;
     return path.endsWith('/') ? `${path}${PROBE}` : `${path}/${PROBE}`;
@@ -28,8 +30,9 @@ function requiresOf(rule, reports) {
         : `${rule.id} stays silent on this source — the fix it recommends is not itself refused`;
 }
 function scenarioOf(rule, proof) {
-    if (typeof proof !== 'string')
-        return proof;
+    if (typeof proof !== 'string') {
+        return { at: canonical(proof.at), files: proof.files.map((one) => ({ ...one, at: canonical(one.at) })) };
+    }
     const path = probeAt(rule);
     return { files: [{ at: path, source: proof }], at: path };
 }
@@ -74,10 +77,95 @@ function config(rule, module, parser) {
                 parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
             },
             plugins: { rule: { rules: { [rule.id]: module } } },
-            rules: { [`rule/`]: 'error' },
+            rules: { [`rule/${rule.id}`]: 'error' },
         },
     ];
 }
+const flat = (at) => (at.length > 1 && at.endsWith('/') ? at.replace(/\/+$/, '') : at);
+const under = (at) => at.startsWith(ROOT) || `${at}/` === ROOT;
+const own = (at) => under(at) && !at.slice(ROOT.length).split('/').includes('node_modules');
+function beside(at) {
+    try {
+        return disk.readdirSync(at, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function outside(at) {
+    const one = disk.statSync(at, { throwIfNoEntry: false });
+    if (one === undefined)
+        return 'none';
+    return one.isFile() ? 'file' : one.isDirectory() ? 'folder' : 'other';
+}
+const GONE = 'is not in the scenario this trial stands, and while it runs the scenario is the whole tree.';
+function answering(files) {
+    const held = new Map(files.map((one) => [resolve(ROOT, one.at), one.source]));
+    const folders = new Set();
+    const parents = (at) => {
+        for (let up = dirname(at); under(`${up}/`); up = dirname(up))
+            folders.add(up);
+    };
+    for (const at of held.keys())
+        parents(at);
+    const answers = {
+        kind: (at) => (held.has(at) ? 'file' : folders.has(at) ? 'folder' : own(at) ? 'none' : outside(at)),
+        read: (at) => {
+            const said = held.get(at);
+            if (said !== undefined)
+                return said;
+            if (own(at))
+                throw new Error(`${at} ${GONE}`);
+            return disk.readFileSync(at, 'utf8');
+        },
+        write: (at, said) => {
+            held.set(at, said);
+            parents(at);
+        },
+        list: (at) => {
+            const inside = new Map();
+            const found = own(at) ? [] : folders.has(at) ? beside(at) : disk.readdirSync(at, { withFileTypes: true });
+            for (const one of found)
+                inside.set(one.name, { name: one.name, kind: one.isDirectory() ? 'folder' : 'file' });
+            for (const path of folders)
+                if (dirname(path) === at)
+                    inside.set(basename(path), { name: basename(path), kind: 'folder' });
+            for (const path of held.keys())
+                if (dirname(path) === at)
+                    inside.set(basename(path), { name: basename(path), kind: 'file' });
+            return [...inside.values()];
+        },
+        stat: (at) => {
+            const said = held.get(at);
+            if (said !== undefined)
+                return { size: said.length, modified: 0 };
+            if (folders.has(at))
+                return { size: 0, modified: 0 };
+            if (own(at))
+                throw new Error(`${at} ${GONE}`);
+            const one = disk.statSync(at);
+            return { size: one.size, modified: one.mtimeMs };
+        },
+        remove: (at) => {
+            held.delete(at);
+            folders.delete(at);
+        },
+        real: (at) => (own(at) || held.has(at) || folders.has(at) ? at : disk.realpathSync(at)),
+    };
+    return {
+        kind: (at) => answers.kind(flat(at)),
+        read: (at) => answers.read(flat(at)),
+        write: (at, said) => {
+            answers.write(flat(at), said);
+        },
+        list: (at) => answers.list(flat(at)),
+        stat: (at) => answers.stat(flat(at)),
+        remove: (at) => {
+            answers.remove(flat(at));
+        },
+        real: (at) => answers.real(flat(at)),
+    };
+}
 export function runTrial(trial, rule, module, parser, slopnator) {
     const linter = new Linter();
     const failures = [];
@@ -91,45 +179,18 @@ export function runTrial(trial, rule, module, parser, slopnator) {
         };
     }
     const target = trial.scenario.files.find((file) => file.at === trial.scenario.at);
-    if (target === undefined) {
-        return {
-            id: trial.id,
-            rule: rule.id,
-            passed: false,
-            parsed: false,
-            failures: [`the scenario writes no file at "${trial.scenario.at}", the path it lints, so nothing could have been measured`],
-        };
-    }
-    for (const file of trial.scenario.files) {
-        if (!existsSync(join(ROOT, file.at)))
-            continue;
-        return {
-            id: trial.id,
-            rule: rule.id,
-            passed: false,
-            parsed: false,
-            failures: [`the scenario would overwrite "${file.at}", which is a real file in this repository — a trial may not stand on a path somebody authored`],
-        };
-    }
-    const written = [];
-    const created = [];
     let parsed = false;
     let satisfied = false;
+    answeredBy(answering(trial.scenario.files));
+    forget();
     try {
-        for (const file of trial.scenario.files) {
-            const path = join(ROOT, file.at);
-            const made = mkdirSync(dirname(path), { recursive: true });
-            if (made !== undefined)
-                created.push(made);
-            writeFileSync(path, file.source);
-            written.push(path);
-        }
-        forget();
-        const path = join(ROOT, trial.scenario.at);
         if (slopnator !== undefined && !reads(slopnator)) {
             parsed = true;
             satisfied = slopnator.checks(ROOT).length > 0 === trial.verdict.reports;
         }
+        else if (target === undefined) {
+            failures.push(`the scenario writes no file at "${trial.scenario.at}", the path it lints, so nothing could have been measured`);
+        }
         else if (slopnator !== undefined && sweeps(slopnator)) {
             const held = slopnator.holds(undefined, {
                 filename: trial.scenario.at,
@@ -143,32 +204,29 @@ export function runTrial(trial, rule, module, parser, slopnator) {
         else {
             for (const wrap of WRAPPINGS) {
                 const text = wrap(target.source);
-                writeFileSync(path, text);
                 const messages = linter.verify(text, config(rule, module, parser), trial.scenario.at);
                 if (messages.some((message) => message.fatal === true))
                     continue;
                 parsed = true;
-                satisfied = messages.some((message) => message.ruleId === `rule/`) === trial.verdict.reports;
+                satisfied = messages.some((message) => message.ruleId === `rule/${rule.id}`) === trial.verdict.reports;
                 break;
             }
         }
     }
+    catch (thrown) {
+        failures.push(`this trial could not run: ${thrown instanceof Error ? thrown.message : String(thrown)} — its scenario does not describe a world this rule can be measured against`);
+    }
     finally {
-        for (const path of written)
-            if (existsSync(path))
-                rmSync(path);
-        for (const path of created)
-            if (existsSync(path))
-                rmSync(path, { recursive: true });
+        answeredBy(undefined);
         forget();
     }
-    if (!parsed) {
+    if (failures.length === 0 && !parsed) {
         failures.push('no wrapping of this source parsed, so nothing was measured — a trial that cannot run is not a trial that passed');
     }
-    else if (!satisfied) {
+    else if (failures.length === 0 && !satisfied) {
         failures.push(trial.verdict.reports
-            ? `expected  to report on this source and it stayed silent — the rule documents a form its own slopnator does not refuse`
-            : `expected  to stay silent on this source and it reported — the rule refuses the fix it recommends`);
+            ? `expected ${rule.id} to report on this source and it stayed silent — the rule documents a form its own slopnator does not refuse`
+            : `expected ${rule.id} to stay silent on this source and it reported — the rule refuses the fix it recommends`);
     }
     return { id: trial.id, rule: rule.id, passed: failures.length === 0, parsed, failures };
 }

package/dist/integrity/generators/trial.ts

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import * as disk from 'node:fs'
+import { answeredBy, existsSync, readFileSync, type Answering, type Kind, type Listed } from '../../core/files.ts'
+import { basename, dirname, join, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 
 import { exit, invoked } from '../../core/invoked.ts'
@@ -7,11 +8,11 @@ import { exit, invoked } from '../../core/invoked.ts'
 import type { Linter as LinterType, Rule } from 'eslint'
 import { Linter } from 'eslint'
 
-import type { Constraint } from '../constraint.ts'
+import type { Constraint, Proof, Sourced } from '../constraint.ts'
 
 const TREE = findTree()
 import { CONSTRAINTS } from '../constraint.ts'
-import { NOT_WRITTEN, ROOT, governs, load, proofsOf, reads, rules, slopnatorName, sweeps, write, type Byproduct, type Proof, type Slopnator, type Sourced } from '../slopnator.ts'
+import { NOT_WRITTEN, ROOT, governs, load, proofsOf, reads, rules, slopnatorName, sweeps, write, type Byproduct, type Slopnator } from '../slopnator.ts'
 import { forget } from '../slopnators/sl_unthreaded.ts'
 import { findTree, inTree } from '../../core/tree.ts'
 
@@ -60,8 +61,10 @@ export interface Run {
   readonly measured: number
 }
 
+const canonical = (at: string): string => at.replace(/^threads\//, `${TREE.name}/`)
+
 export function probeAt(rule: Constraint): string {
-  const path = rule.where.paths[0] ?? 'src/'
+  const path = canonical(rule.where.paths[0] ?? 'src/')
   if (path === '.') return PROBE
   return path.endsWith('/') ? `${path}${PROBE}` : `${path}/${PROBE}`
 }
@@ -73,7 +76,9 @@ function requiresOf(rule: Constraint, reports: boolean): string {
 }
 
 function scenarioOf(rule: Constraint, proof: Proof): Scenario {
-  if (typeof proof !== 'string') return proof
+  if (typeof proof !== 'string') {
+    return { at: canonical(proof.at), files: proof.files.map((one) => ({ ...one, at: canonical(one.at) })) }
+  }
   const path = probeAt(rule)
   return { files: [{ at: path, source: proof }], at: path }
 }
@@ -124,11 +129,91 @@ function config(rule: Constraint, module: Rule.RuleModule, parser: unknown): Par
         parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
       },
       plugins: { rule: { rules: { [rule.id]: module } } },
-      rules: { [`rule/`]: 'error' },
+      rules: { [`rule/${rule.id}`]: 'error' },
     },
   ] as unknown as Parameters<LinterType['verify']>[1]
 }
 
+const flat = (at: string): string => (at.length > 1 && at.endsWith('/') ? at.replace(/\/+$/, '') : at)
+
+const under = (at: string): boolean => at.startsWith(ROOT) || `${at}/` === ROOT
+
+const own = (at: string): boolean => under(at) && !at.slice(ROOT.length).split('/').includes('node_modules')
+
+function beside(at: string): readonly disk.Dirent[] {
+  try {
+    return disk.readdirSync(at, { withFileTypes: true })
+  } catch {
+    return []
+  }
+}
+
+function outside(at: string): Kind {
+  const one = disk.statSync(at, { throwIfNoEntry: false })
+  if (one === undefined) return 'none'
+  return one.isFile() ? 'file' : one.isDirectory() ? 'folder' : 'other'
+}
+
+const GONE = 'is not in the scenario this trial stands, and while it runs the scenario is the whole tree.'
+
+function answering(files: readonly Sourced[]): Answering {
+  const held = new Map<string, string>(files.map((one) => [resolve(ROOT, one.at), one.source]))
+  const folders = new Set<string>()
+  const parents = (at: string): void => {
+    for (let up = dirname(at); under(`${up}/`); up = dirname(up)) folders.add(up)
+  }
+  for (const at of held.keys()) parents(at)
+
+  const answers: Answering = {
+    kind: (at) => (held.has(at) ? 'file' : folders.has(at) ? 'folder' : own(at) ? 'none' : outside(at)),
+    read: (at) => {
+      const said = held.get(at)
+      if (said !== undefined) return said
+      if (own(at)) throw new Error(`${at} ${GONE}`)
+      return disk.readFileSync(at, 'utf8')
+    },
+    write: (at, said) => {
+      held.set(at, said)
+      parents(at)
+    },
+    list: (at) => {
+      const inside = new Map<string, Listed>()
+      const found = own(at) ? [] : folders.has(at) ? beside(at) : disk.readdirSync(at, { withFileTypes: true })
+      for (const one of found) inside.set(one.name, { name: one.name, kind: one.isDirectory() ? 'folder' : 'file' })
+      for (const path of folders) if (dirname(path) === at) inside.set(basename(path), { name: basename(path), kind: 'folder' })
+      for (const path of held.keys()) if (dirname(path) === at) inside.set(basename(path), { name: basename(path), kind: 'file' })
+      return [...inside.values()]
+    },
+    stat: (at) => {
+      const said = held.get(at)
+      if (said !== undefined) return { size: said.length, modified: 0 }
+      if (folders.has(at)) return { size: 0, modified: 0 }
+      if (own(at)) throw new Error(`${at} ${GONE}`)
+      const one = disk.statSync(at)
+      return { size: one.size, modified: one.mtimeMs }
+    },
+    remove: (at) => {
+      held.delete(at)
+      folders.delete(at)
+    },
+    real: (at) => (own(at) || held.has(at) || folders.has(at) ? at : disk.realpathSync(at)),
+  }
+
+  return {
+    kind: (at) => answers.kind(flat(at)),
+    read: (at) => answers.read(flat(at)),
+    write: (at, said) => {
+      answers.write(flat(at), said)
+    },
+    list: (at) => answers.list(flat(at)),
+    stat: (at) => answers.stat(flat(at)),
+    remove: (at) => {
+      answers.remove(flat(at))
+    },
+    real: (at) => answers.real(flat(at)),
+  }
+}
+
 export function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule, parser: unknown, slopnator?: Slopnator): Outcome {
   const linter = new Linter()
   const failures: string[] = []
@@ -144,47 +229,19 @@ export function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule
   }
 
   const target = trial.scenario.files.find((file) => file.at === trial.scenario.at)
-  if (target === undefined) {
-    return {
-      id: trial.id,
-      rule: rule.id,
-      passed: false,
-      parsed: false,
-      failures: [`the scenario writes no file at "${trial.scenario.at}", the path it lints, so nothing could have been measured`],
-    }
-  }
-
-  for (const file of trial.scenario.files) {
-    if (!existsSync(join(ROOT, file.at))) continue
-    return {
-      id: trial.id,
-      rule: rule.id,
-      passed: false,
-      parsed: false,
-      failures: [`the scenario would overwrite "${file.at}", which is a real file in this repository — a trial may not stand on a path somebody authored`],
-    }
-  }
 
-  const written: string[] = []
-  const created: string[] = []
   let parsed = false
   let satisfied = false
 
-  try {
-    for (const file of trial.scenario.files) {
-      const path = join(ROOT, file.at)
-      const made = mkdirSync(dirname(path), { recursive: true })
-      if (made !== undefined) created.push(made)
-      writeFileSync(path, file.source)
-      written.push(path)
-    }
-    forget()
-
-    const path = join(ROOT, trial.scenario.at)
+  answeredBy(answering(trial.scenario.files))
+  forget()
 
+  try {
     if (slopnator !== undefined && !reads(slopnator)) {
       parsed = true
       satisfied = slopnator.checks(ROOT).length > 0 === trial.verdict.reports
+    } else if (target === undefined) {
+      failures.push(`the scenario writes no file at "${trial.scenario.at}", the path it lints, so nothing could have been measured`)
     } else if (slopnator !== undefined && sweeps(slopnator)) {
       const held = slopnator.holds(undefined, {
         filename: trial.scenario.at,
@@ -197,27 +254,29 @@ export function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule
     } else {
       for (const wrap of WRAPPINGS) {
         const text = wrap(target.source)
-        writeFileSync(path, text)
         const messages = linter.verify(text, config(rule, module, parser), trial.scenario.at)
         if (messages.some((message) => message.fatal === true)) continue
         parsed = true
-        satisfied = messages.some((message) => message.ruleId === `rule/`) === trial.verdict.reports
+        satisfied = messages.some((message) => message.ruleId === `rule/${rule.id}`) === trial.verdict.reports
         break
       }
     }
+  } catch (thrown) {
+    failures.push(
+      `this trial could not run: ${thrown instanceof Error ? thrown.message : String(thrown)} — its scenario does not describe a world this rule can be measured against`,
+    )
   } finally {
-    for (const path of written) if (existsSync(path)) rmSync(path)
-    for (const path of created) if (existsSync(path)) rmSync(path, { recursive: true })
+    answeredBy(undefined)
     forget()
   }
 
-  if (!parsed) {
+  if (failures.length === 0 && !parsed) {
     failures.push('no wrapping of this source parsed, so nothing was measured — a trial that cannot run is not a trial that passed')
-  } else if (!satisfied) {
+  } else if (failures.length === 0 && !satisfied) {
     failures.push(
       trial.verdict.reports
-        ? `expected  to report on this source and it stayed silent — the rule documents a form its own slopnator does not refuse`
-        : `expected  to stay silent on this source and it reported — the rule refuses the fix it recommends`,
+        ? `expected ${rule.id} to report on this source and it stayed silent — the rule documents a form its own slopnator does not refuse`
+        : `expected ${rule.id} to stay silent on this source and it reported — the rule refuses the fix it recommends`,
     )
   }
 

package/dist/integrity/lint.js

@@ -2,7 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { Linter } from 'eslint';
 import tseslint from 'typescript-eslint';
 import { THING } from "../core/scope.js";
-import { CONSTRAINTS } from "./constraint.js";
+import { CONSTRAINTS, shown } from "./constraint.js";
 import { NOT_WRITTEN, governs, reads, visits, load, ROOT, rules as appRules, slopnatorName, } from "./slopnator.js";
 const PROBE = {
     filename: 'probe.ts',
@@ -18,7 +18,7 @@ const oneLine = (text) => text.replace(/\s*\n\s*/g, ' ').trim();
 export function agentInstructions() {
     return [...CONSTRAINTS]
         .sort((one, two) => (one.id < two.id ? -1 : one.id > two.id ? 1 : 0))
-        .map((rule) => `${oneLine(rule.instead)} — never ${oneLine(rule.bans)}. Wrong: \`${oneLine(rule.wrong)}\`. Right: \`${oneLine(rule.right)}\`. [${rule.id}]`);
+        .map((rule) => `${oneLine(rule.instead)} — never ${oneLine(rule.bans)}. Wrong: \`${oneLine(shown(rule.wrong))}\`. Right: \`${oneLine(shown(rule.right))}\`. [${rule.id}]`);
 }
 export function defineRule(rule, slopnators) {
     const expected = slopnatorName(rule.id);
@@ -155,7 +155,7 @@ export function theRules() {
             message: message.message,
             ...(found === undefined
                 ? {}
-                : { bans: found.bans, instead: found.instead, wrong: found.wrong, right: found.right }),
+                : { bans: found.bans, instead: found.instead, wrong: shown(found.wrong), right: shown(found.right) }),
         };
     });
 }

package/dist/integrity/lint.ts

@@ -5,7 +5,7 @@ import { Linter, type Rule } from 'eslint'
 import tseslint from 'typescript-eslint'
 
 import { THING } from '../core/scope.ts'
-import { CONSTRAINTS, type Constraint } from './constraint.ts'
+import { CONSTRAINTS, shown, type Constraint } from './constraint.ts'
 import {
   NOT_WRITTEN,
   governs,
@@ -40,7 +40,7 @@ export function agentInstructions(): readonly string[] {
     .sort((one, two) => (one.id < two.id ? -1 : one.id > two.id ? 1 : 0))
     .map(
       (rule) =>
-        `${oneLine(rule.instead)} — never ${oneLine(rule.bans)}. Wrong: \`${oneLine(rule.wrong)}\`. Right: \`${oneLine(rule.right)}\`. [${rule.id}]`,
+        `${oneLine(rule.instead)} — never ${oneLine(rule.bans)}. Wrong: \`${oneLine(shown(rule.wrong))}\`. Right: \`${oneLine(shown(rule.right))}\`. [${rule.id}]`,
     )
 }
 
@@ -221,7 +221,7 @@ export function theRules(): RuleRunner {
           message: message.message,
           ...(found === undefined
             ? {}
-            : { bans: found.bans, instead: found.instead, wrong: found.wrong, right: found.right }),
+            : { bans: found.bans, instead: found.instead, wrong: shown(found.wrong), right: shown(found.right) }),
         }
       })
 }

package/dist/integrity/lsp/diagnostics.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { readFileSync } from "../../core/files.js";
 import { join } from 'node:path';
 import { detailOf, rangeOf } from "./findings.js";
 import { lintFindings } from "./lint.js";

package/dist/integrity/lsp/diagnostics.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs'
+import { readFileSync } from '../../core/files.ts'
 import { join } from 'node:path'
 
 import { detailOf, rangeOf, type Finding } from './findings.ts'

package/dist/integrity/lsp/lint.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync } from "../../core/files.js";
 import { extname, join } from 'node:path';
 import { theRules } from "../lint.js";
 const LINTABLE = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.mjs', '.cjs', '.jsx']);

package/dist/integrity/lsp/lint.ts

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process'
-import { existsSync } from 'node:fs'
+import { existsSync } from '../../core/files.ts'
 import { extname, join } from 'node:path'
 
 import { theRules } from '../lint.ts'