@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/generators/trial.ts

@@ -1,9 +1,5 @@
-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'
+import { answeredBy, standing } from '../../integrations/disk.ts'
+import { resolve } from 'node:path'
 
 import type { Linter as LinterType, Rule } from 'eslint'
 import { Linter } from 'eslint'
@@ -11,12 +7,9 @@ import { Linter } from 'eslint'
 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 Slopnator } from '../slopnator.ts'
+import { NOT_WRITTEN, ROOT, governs, proofsOf, reads, slopnatorName, sweeps, visits, type Slopnator } from '../slopnator.ts'
 import { forget } from '../slopnators/sl_unthreaded.ts'
-import { findTree, inTree } from '../../core/tree.ts'
-
-export const TRIALS_PATH = `${findTree().name}/_generated/trials.ts`
+import { findTree } from '../../core/tree.ts'
 
 const PROBE = 'probe.tsx'
 
@@ -59,6 +52,7 @@ export interface Run {
   readonly passed: number
   readonly failed: number
   readonly measured: number
+  readonly spent: ReadonlyMap<string, number>
 }
 
 const canonical = (at: string): string => at.replace(/^threads\//, `${TREE.name}/`)
@@ -112,14 +106,6 @@ export function deriveTrials(all: readonly Constraint[], slopnators: ReadonlyMap
   return { trials: trials.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) }
 }
 
-export function trialsByproduct(derivation: Derivation): Byproduct {
-  return {
-    path: TRIALS_PATH,
-    content: `export const RULE_TRIALS = ${JSON.stringify(derivation.trials, null, 2)} as const
-`,
-  }
-}
-
 function config(rule: Constraint, module: Rule.RuleModule, parser: unknown): Parameters<LinterType['verify']>[1] {
   return [
     {
@@ -134,90 +120,6 @@ function config(rule: Constraint, module: Rule.RuleModule, parser: unknown): Par
   ] 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)),
-    fetch: () => {
-      throw new Error('a trial answers orders against a tree it made up, so there is nowhere here to install anything into.')
-    },
-  }
-
-  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)),
-    fetch: (at) => answers.fetch(flat(at)),
-  }
-}
-
 export function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule, parser: unknown, slopnator?: Slopnator): Outcome {
   const linter = new Linter()
   const failures: string[] = []
@@ -237,7 +139,7 @@ export function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule
   let parsed = false
   let satisfied = false
 
-  answeredBy(answering(trial.scenario.files))
+  answeredBy(standing(ROOT, new Map<string, string>(trial.scenario.files.map((one) => [resolve(ROOT, one.at), one.source]))))
   forget()
 
   try {
@@ -287,6 +189,138 @@ export function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule
   return { id: trial.id, rule: rule.id, passed: failures.length === 0, parsed, failures }
 }
 
+const judged = (who: readonly Constraint[], rules: Readonly<Record<string, Rule.RuleModule>>, parser: unknown): Parameters<LinterType['verify']>[1] =>
+  [
+    {
+      files: ['**/*.ts', '**/*.tsx'],
+      languageOptions: {
+        parser,
+        parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
+      },
+      plugins: { rule: { rules: Object.fromEntries(who.map((one) => [one.id, rules[one.id] as Rule.RuleModule])) } },
+      rules: Object.fromEntries(who.map((one) => ['rule/' + one.id, 'error'])),
+    },
+  ] as unknown as Parameters<LinterType['verify']>[1]
+
+const failed = (thrown: unknown): string => 'could not run on it: ' + (thrown instanceof Error ? thrown.message : String(thrown))
+
+const parseable = (source: string, at: string, parser: unknown): ((said: string) => string) =>
+  WRAPPINGS.find((wrap) => !new Linter().verify(wrap(source), judged([], {}, parser), at).some((one) => one.fatal === true)) ??
+  ((said: string): string => said)
+
+function refusals(
+  scenario: Scenario,
+  source: string,
+  judges: readonly Constraint[],
+  rules: Readonly<Record<string, Rule.RuleModule>>,
+  parser: unknown,
+  slopnators: ReadonlyMap<string, Slopnator>,
+): ReadonlyMap<string, ReadonlySet<string>> {
+  const found = new Map<string, Set<string>>()
+  const note = (who: string, said: string): void => {
+    const held = found.get(who) ?? new Set<string>()
+    held.add(said)
+    found.set(who, held)
+  }
+  const walking = judges.filter((one) => {
+    const held = slopnators.get(slopnatorName(one.id))
+    return held !== undefined && visits(held) && rules[one.id] !== undefined
+  })
+  const linted = (who: readonly Constraint[]): void => {
+    const messages = new Linter().verify(source, judged(who, rules, parser), scenario.at)
+    if (messages.some((one) => one.fatal === true)) return
+    for (const one of messages) {
+      const by = String(one.ruleId ?? '').replace('rule/', '')
+      if (by !== '') note(by, one.message)
+    }
+  }
+
+  const files = scenario.files.map((one) => (one.at === scenario.at ? { at: one.at, source } : one))
+  answeredBy(standing(ROOT, new Map<string, string>(files.map((one) => [resolve(ROOT, one.at), one.source]))))
+  forget()
+  try {
+    try {
+      linted(walking)
+    } catch {
+      for (const one of walking) {
+        try {
+          linted([one])
+        } catch (thrown) {
+          note(one.id, failed(thrown))
+        }
+      }
+    }
+    for (const one of judges) {
+      const held = slopnators.get(slopnatorName(one.id))
+      if (held === undefined) continue
+      if (visits(held)) continue
+      try {
+        if (sweeps(held)) {
+          const said = held.holds(undefined, { filename: scenario.at, text: source, ancestors: () => [], comments: () => [] })
+          if (said !== false && said !== NOT_WRITTEN) note(one.id, typeof said === 'string' ? said : slopnatorName(one.id))
+          continue
+        }
+        if (!reads(held)) for (const said of held.checks(ROOT)) note(one.id, said)
+      } catch (thrown) {
+        note(one.id, failed(thrown))
+      }
+    }
+  } finally {
+    answeredBy(undefined)
+    forget()
+  }
+  return found
+}
+
+export function crossed(
+  trials: readonly Trial[],
+  all: readonly Constraint[],
+  rules: Readonly<Record<string, Rule.RuleModule>>,
+  parser: unknown,
+  slopnators: ReadonlyMap<string, Slopnator> = new Map<string, Slopnator>(),
+  spent: Map<string, number> = new Map<string, number>(),
+): readonly Outcome[] {
+  const found: Outcome[] = []
+  const blanks = new Map<string, ReadonlyMap<string, ReadonlySet<string>>>()
+
+  for (const trial of trials) {
+    if (trial.verdict.reports) continue
+    const target = trial.scenario.files.find((one) => one.at === trial.scenario.at)
+    if (target === undefined) continue
+
+    const judges = all.filter((one) => governs(one, trial.scenario.at))
+    if (!judges.some((one) => one.id !== trial.rule)) continue
+    const began = Date.now()
+
+    const wrap = parseable(target.source, trial.scenario.at, parser)
+    const emptied = JSON.stringify([wrap(''), trial.scenario.files.map((one) => (one.at === trial.scenario.at ? { at: one.at, source: '' } : one))])
+    const blank = blanks.get(emptied) ?? refusals(trial.scenario, wrap(''), judges, rules, parser, slopnators)
+    blanks.set(emptied, blank)
+    const said = refusals(trial.scenario, wrap(target.source), judges, rules, parser, slopnators)
+
+    spent.set(trial.rule, (spent.get(trial.rule) ?? 0) + Date.now() - began)
+
+    for (const [who, messages] of said) {
+      if (who === trial.rule) continue
+      for (const message of messages) {
+        if (blank.get(who)?.has(message) === true) continue
+        found.push({
+          id: trial.id + '_under_' + who.replace(/-/g, '_'),
+          rule: trial.rule,
+          passed: false,
+          parsed: true,
+          failures: [
+            'the form it recommends is refused by ' + who + ', so this law tells somebody to write what another law bans. ' +
+              who + ' said: ' + (message.split('Found: ').pop() ?? message),
+          ],
+        })
+      }
+    }
+  }
+
+  return found
+}
+
 export function runTrials(
   trials: readonly Trial[],
   all: readonly Constraint[],
@@ -295,6 +329,7 @@ export function runTrials(
   slopnators?: ReadonlyMap<string, Slopnator>,
 ): Run {
   const byName = new Map(all.map((rule) => [rule.id, rule]))
+  const spent = new Map<string, number>()
   const outcomes = trials.map((trial): Outcome => {
     const rule = byName.get(trial.rule)
     const module = rules[trial.rule]
@@ -304,10 +339,13 @@ export function runTrials(
         rule: trial.rule,
         passed: false,
         parsed: false,
-        failures: [`no rule named "${trial.rule}" is registered, so this trial is about nothing — regenerate with \`thread trials\``],
+        failures: [`the rule "${trial.rule}" has no slopnator on disk, so this trial is about nothing — the file to write is the one its row names in \`at\``],
       }
     }
-    return runTrial(trial, rule, module, parser, slopnators?.get(slopnatorName(rule.id)))
+    const began = Date.now()
+    const outcome = runTrial(trial, rule, module, parser, slopnators?.get(slopnatorName(rule.id)))
+    spent.set(trial.rule, (spent.get(trial.rule) ?? 0) + Date.now() - began)
+    return outcome
   })
 
   return {
@@ -315,69 +353,7 @@ export function runTrials(
     passed: outcomes.filter((outcome) => outcome.passed).length,
     failed: outcomes.filter((outcome) => !outcome.passed).length,
     measured: outcomes.filter((outcome) => outcome.parsed).length,
+    spent,
   }
 }
 
-if (invoked(import.meta.url)) {
-  const own = await rules()
-  const governing = own ?? CONSTRAINTS
-  const source =
-    own === undefined
-      ? `the ${String(CONSTRAINTS.length)} constraint(s) this tree authors`
-      : `the ${String(own.length)} rule(s) this tree declares — a shipped constraint is proved in the package that ships it, against the paths that package governs`
-  const slopnators = await load(ROOT, governing)
-  const derivation = deriveTrials(governing, slopnators)
-  const byproduct = trialsByproduct(derivation)
-
-  if (process.argv.includes('--check')) {
-    const path = join(ROOT, byproduct.path)
-    const current = existsSync(path) ? readFileSync(path, 'utf8') : ''
-    const drifted = current !== byproduct.content
-    if (drifted) console.error(`trial: ${byproduct.path} is not what the rules derive. Run \`thread trials\` and commit the result.`)
-    console.log(`trial: ${String(derivation.trials.length)} derived from ${source}, ${String(drifted ? 1 : 0)} findings.`)
-    exit(drifted ? 1 : 0)
-  }
-
-  if (process.argv.includes('--try')) {
-    const at = process.argv.indexOf('--rule')
-    const only = at === -1 ? undefined : (process.argv[at + 1] ?? '').split(',').map((one) => one.trim()).filter(Boolean)
-    const unknown = (only ?? []).filter((id) => !governing.some((rule) => rule.id === id))
-    if (unknown.length > 0) {
-      console.error(`trial: no rule is called ${unknown.join(', ')} — a filter naming nothing would measure nothing and exit 0`)
-      exit(1)
-    }
-    const chosen = only === undefined ? derivation.trials : derivation.trials.filter((trial) => only.includes(trial.rule))
-    if (chosen.length === 0) {
-      if (only !== undefined) {
-        console.error('trial: the filter selected no trials, and measuring nothing must not exit 0')
-        exit(1)
-      }
-      if (governing.length > 0) {
-        console.error(
-          `trial: ${String(governing.length)} rule(s) govern and none derived a trial — every rule owes a \`wrong\` and a \`right\`, so measuring nothing must not exit 0`,
-        )
-        exit(1)
-      }
-      console.log(`trial: nothing to prove — ${source}.`)
-      exit(0)
-    }
-
-    const { default: plugin } = await import('../lint.ts')
-    const parser = (await import('typescript-eslint')).parser
-    const run = runTrials(chosen, governing, plugin.rules, parser, slopnators)
-    for (const outcome of run.outcomes) {
-      if (outcome.passed) continue
-      for (const failure of outcome.failures) console.error(`trial: ${outcome.id} — ${failure}`)
-    }
-    console.log(`trial: ${String(run.passed)} of ${String(run.outcomes.length)} passed, ${String(run.measured)} measured.`)
-    if (only !== undefined) {
-      console.log(
-        `trial: PARTIAL RUN — ${String(derivation.trials.length - chosen.length)} of ${String(derivation.trials.length)} derived trials did not run. \`thread trials\` with no arguments runs every one.`,
-      )
-    }
-    exit(run.failed === 0 ? 0 : 1)
-  }
-
-  write(ROOT, byproduct)
-  console.log(`trial: wrote ${byproduct.path} — ${String(derivation.trials.length)} trials from ${source}.`)
-}

package/dist/integrity/lint.js

@@ -1,9 +1,9 @@
-import { execFileSync } from 'node:child_process';
+import { starts } from '../integrations/cli.js';
 import { Linter } from 'eslint';
 import tseslint from 'typescript-eslint';
-import { THING } from "../core/scope.js";
-import { CONSTRAINTS, shown } from "./constraint.js";
-import { NOT_WRITTEN, governs, reads, visits, load, ROOT, rules as appRules, slopnatorName, } from "./slopnator.js";
+import { THING } from '../core/scope.js';
+import { CONSTRAINTS, shown } from './constraint.js';
+import { NOT_WRITTEN, governs, subject, reads, visits, load, ROOT, rules as appRules, slopnatorName, } from './slopnator.js';
 const PROBE = {
     filename: 'probe.ts',
     text: '',
@@ -61,7 +61,7 @@ export function ruleRule(rule, slopnators) {
                 return {};
             const visit = (node) => {
                 const at = {
-                    filename: context.filename,
+                    filename: context.filename.startsWith(ROOT) ? context.filename.slice(ROOT.length) : context.filename,
                     text: context.sourceCode.getText(),
                     ancestors: () => context.sourceCode.getAncestors(node),
                     comments: () => context.sourceCode.getAllComments().map((comment) => ({
@@ -89,7 +89,7 @@ export function ruleRules(slopnators) {
     return Object.fromEntries(GOVERNING.map((rule) => [rule.id, ruleRule(rule, slopnators)]));
 }
 export function ruleSeverities() {
-    return Object.fromEntries(GOVERNING.map((rule) => [`lint/${rule.id}`, rule.severity === 'warning' ? 'warn' : 'error']));
+    return Object.fromEntries(GOVERNING.filter((rule) => subject(rule)).map((rule) => [`lint/${rule.id}`, rule.severity === 'warning' ? 'warn' : 'error']));
 }
 const GOVERNING = [...CONSTRAINTS, ...((await appRules()) ?? [])];
 const SLOPNATORS = await load(ROOT, GOVERNING);
@@ -98,12 +98,8 @@ export const plugin = { rules: ruleRules(SLOPNATORS) };
 export default plugin;
 function ignored() {
     try {
-        return execFileSync('git', ['ls-files', '--others', '--ignored', '--exclude-standard', '--directory'], {
-            cwd: ROOT,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        })
-            .split('\n')
+        return starts('git', ['ls-files', '--others', '--ignored', '--exclude-standard', '--directory'], { at: ROOT })
+            .out.split('\n')
             .filter(Boolean)
             .map((one) => (one.endsWith('/') ? one + '**' : one));
     }
@@ -138,7 +134,7 @@ export function theRules() {
                 parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
             },
             plugins: { [`@${THING}`]: plugin },
-            rules: Object.fromEntries(GOVERNING.map((rule) => [`@${THING}/${rule.id}`, rule.severity === 'warning' ? 'warn' : 'error'])),
+            rules: Object.fromEntries(GOVERNING.filter((rule) => subject(rule)).map((rule) => [`@${THING}/${rule.id}`, rule.severity === 'warning' ? 'warn' : 'error'])),
         },
     ];
     return (file, source) => linter

package/dist/integrity/lint.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from 'node:child_process'
+import { starts } from '../integrations/cli.ts'
 import { fileURLToPath } from 'node:url'
 
 import { Linter, type Rule } from 'eslint'
@@ -9,6 +9,7 @@ import { CONSTRAINTS, shown, type Constraint } from './constraint.ts'
 import {
   NOT_WRITTEN,
   governs,
+  subject,
   reads,
   visits,
   load,
@@ -91,7 +92,7 @@ export function ruleRule(rule: Constraint, slopnators: ReadonlyMap<string, Slopn
       if (found === undefined || !visits(found)) return {}
       const visit = (node: unknown): void => {
         const at: SlopnatorContext = {
-          filename: context.filename,
+          filename: context.filename.startsWith(ROOT) ? context.filename.slice(ROOT.length) : context.filename,
           text: context.sourceCode.getText(),
           ancestors: () => context.sourceCode.getAncestors(node as never),
           comments: () =>
@@ -122,7 +123,7 @@ export function ruleRules(slopnators: ReadonlyMap<string, Slopnator>): Readonly<
 
 export function ruleSeverities(): Readonly<Record<string, 'error' | 'warn'>> {
   return Object.fromEntries(
-    GOVERNING.map((rule) => [`lint/${rule.id}`, rule.severity === 'warning' ? ('warn' as const) : ('error' as const)]),
+    GOVERNING.filter((rule) => subject(rule)).map((rule) => [`lint/${rule.id}`, rule.severity === 'warning' ? ('warn' as const) : ('error' as const)]),
   )
 }
 
@@ -137,12 +138,8 @@ export default plugin
 
 function ignored(): readonly string[] {
   try {
-    return execFileSync('git', ['ls-files', '--others', '--ignored', '--exclude-standard', '--directory'], {
-      cwd: ROOT,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    })
-      .split('\n')
+    return starts('git', ['ls-files', '--others', '--ignored', '--exclude-standard', '--directory'], { at: ROOT })
+      .out.split('\n')
       .filter(Boolean)
       .map((one) => (one.endsWith('/') ? one + '**' : one))
   } catch {
@@ -201,7 +198,7 @@ export function theRules(): RuleRunner {
       },
       plugins: { [`@${THING}`]: plugin },
       rules: Object.fromEntries(
-        GOVERNING.map((rule) => [`@${THING}/${rule.id}`, rule.severity === 'warning' ? 'warn' : 'error']),
+        GOVERNING.filter((rule) => subject(rule)).map((rule) => [`@${THING}/${rule.id}`, rule.severity === 'warning' ? 'warn' : 'error']),
       ),
     },
   ] as unknown as Parameters<InstanceType<typeof Linter>['verify']>[1]

package/dist/integrity/lsp/bin.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { cwd, exit, stderr, stdin, stdout } from 'node:process';
-import { repoSource } from "./diagnostics.js";
-import { encode, MessageBuffer } from "./protocol.js";
-import { LspServer } from "./server.js";
+import { cwd, stderr, stdin, stdout } from 'node:process';
+import { exit } from '../../core/invoked.js';
+import { repoSource } from './diagnostics.js';
+import { encode, MessageBuffer } from './protocol.js';
+import { LspServer } from './server.js';
 const server = new LspServer({
     root: cwd(),
     sourceFor: repoSource,

package/dist/integrity/lsp/bin.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
-import { cwd, exit, stderr, stdin, stdout } from 'node:process'
+import { cwd, stderr, stdin, stdout } from 'node:process'
+
+import { exit } from '../../core/invoked.ts'
 
 import { repoSource } from './diagnostics.ts'
 import { encode, MessageBuffer } from './protocol.ts'

package/dist/integrity/lsp/diagnostics.js

@@ -1,7 +1,7 @@
-import { readFileSync } from "../../core/files.js";
+import { readFileSync } from '../../integrations/disk.js';
 import { join } from 'node:path';
-import { detailOf, rangeOf } from "./findings.js";
-import { lintFindings } from "./lint.js";
+import { detailOf, rangeOf } from './findings.js';
+import { lintFindings } from './lint.js';
 export function repoSource(root) {
     return {
         lint: (relative, text) => lintFindings(root, relative, text),

package/dist/integrity/lsp/diagnostics.ts

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

package/dist/integrity/lsp/lint.js

@@ -1,7 +1,7 @@
-import { spawn } from 'node:child_process';
-import { existsSync } from "../../core/files.js";
+import { started } from '../../integrations/cli.js';
+import { existsSync } from '../../integrations/disk.js';
 import { extname, join } from 'node:path';
-import { theRules } from "../lint.js";
+import { theRules } from '../lint.js';
 const LINTABLE = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.mjs', '.cjs', '.jsx']);
 export const isLintable = (relative) => LINTABLE.has(extname(relative));
 export const LINT_CONFIG = 'eslint.config.js';
@@ -64,32 +64,21 @@ export async function lintFindings(root, relative, text) {
         ...(suggestionsOf(message).length === 0 ? {} : { suggestions: suggestionsOf(message) }),
     })));
 }
-function runEslint(binary, root, relative, text) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(binary, ['--format', 'json', '--no-warn-ignored', '--stdin', '--stdin-filename', relative], {
-            cwd: root,
-            shell: false,
-        });
-        let out = '';
-        let err = '';
-        child.stdout.on('data', (chunk) => (out += chunk.toString()));
-        child.stderr.on('data', (chunk) => (err += chunk.toString()));
-        child.on('error', (error) => reject(new LintUnavailableError(error.message)));
-        child.on('close', () => {
-            let parsed;
-            try {
-                parsed = JSON.parse(out);
-            }
-            catch {
-                reject(new LintUnavailableError(err.trim() === '' ? `it wrote ${out.length} bytes of non-JSON` : err.trim()));
-                return;
-            }
-            if (!Array.isArray(parsed)) {
-                reject(new LintUnavailableError('its JSON report was not an array of files'));
-                return;
-            }
-            resolve(parsed);
-        });
-        child.stdin.end(text);
+async function runEslint(binary, root, relative, text) {
+    const went = await started(binary, ['--format', 'json', '--no-warn-ignored', '--stdin', '--stdin-filename', relative], {
+        at: root,
+        hears: text,
     });
+    if (!went.there)
+        throw new LintUnavailableError(went.why);
+    let parsed;
+    try {
+        parsed = JSON.parse(went.out);
+    }
+    catch {
+        throw new LintUnavailableError(went.err.trim() === '' ? `it wrote ${went.out.length} bytes of non-JSON` : went.err.trim());
+    }
+    if (!Array.isArray(parsed))
+        throw new LintUnavailableError('its JSON report was not an array of files');
+    return parsed;
 }

package/dist/integrity/lsp/lint.ts

@@ -1,5 +1,5 @@
-import { spawn } from 'node:child_process'
-import { existsSync } from '../../core/files.ts'
+import { started } from '../../integrations/cli.ts'
+import { existsSync } from '../../integrations/disk.ts'
 import { extname, join } from 'node:path'
 
 import { theRules } from '../lint.ts'
@@ -101,40 +101,24 @@ export async function lintFindings(root: string, relative: string, text: string)
   )
 }
 
-function runEslint(
+async function runEslint(
   binary: string,
   root: string,
   relative: string,
   text: string,
 ): Promise<readonly EslintFile[]> {
-  return new Promise((resolve, reject) => {
-
-    const child = spawn(binary, ['--format', 'json', '--no-warn-ignored', '--stdin', '--stdin-filename', relative], {
-      cwd: root,
-      shell: false,
-    })
-
-    let out = ''
-    let err = ''
-    child.stdout.on('data', (chunk: Buffer) => (out += chunk.toString()))
-    child.stderr.on('data', (chunk: Buffer) => (err += chunk.toString()))
-    child.on('error', (error) => reject(new LintUnavailableError(error.message)))
-    child.on('close', () => {
-
-      let parsed: unknown
-      try {
-        parsed = JSON.parse(out)
-      } catch {
-        reject(new LintUnavailableError(err.trim() === '' ? `it wrote ${out.length} bytes of non-JSON` : err.trim()))
-        return
-      }
-      if (!Array.isArray(parsed)) {
-        reject(new LintUnavailableError('its JSON report was not an array of files'))
-        return
-      }
-      resolve(parsed as readonly EslintFile[])
-    })
-
-    child.stdin.end(text)
+  const went = await started(binary, ['--format', 'json', '--no-warn-ignored', '--stdin', '--stdin-filename', relative], {
+    at: root,
+    hears: text,
   })
+  if (!went.there) throw new LintUnavailableError(went.why)
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(went.out)
+  } catch {
+    throw new LintUnavailableError(went.err.trim() === '' ? `it wrote ${went.out.length} bytes of non-JSON` : went.err.trim())
+  }
+  if (!Array.isArray(parsed)) throw new LintUnavailableError('its JSON report was not an array of files')
+  return parsed as readonly EslintFile[]
 }

package/dist/integrity/lsp/server.js

@@ -1,8 +1,8 @@
 import { relative as relativeTo, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { named } from "../../core/scope.js";
-import { report, SOURCE_NAME } from "./diagnostics.js";
-import { METHOD_NOT_FOUND } from "./protocol.js";
+import { named } from '../../core/scope.js';
+import { report, SOURCE_NAME } from './diagnostics.js';
+import { METHOD_NOT_FOUND } from './protocol.js';
 const SYNC_FULL = 1;
 export class LspServer {
     #root;