@prestack/thread 0.1.20 → 0.1.22

package/dist/integrity/generators/publish.ts

@@ -1,232 +0,0 @@
-import { calls, starts } from '../../integrations/cli.ts'
-import { existsSync, readFileSync } from '../../integrations/disk.ts'
-import { valuesIn } from '../../core/rows.ts'
-import { join } from 'node:path'
-import { argv, env, execPath, stderr, stdout } from 'node:process'
-import { CLI, exit } from '../../core/invoked.ts'
-import { THING as TYPED, named } from '../../core/scope.ts'
-import { findTree, inTree } from '../../core/tree.ts'
-
-import type { Secret } from '../../integrations/secret.ts'
-import { placedAt, type Target } from '../../integrations/target.ts'
-import { opened, sealedIn } from '../../integrations/vault.ts'
-
-const TREE = findTree()
-const ROOT = TREE.at
-
-const STEP_TIMEOUT = 900_000
-
-const REGISTRY = 'ht_registry'
-
-interface Check {
-  readonly id: string
-  readonly runs: string
-  readonly because: string
-}
-
-const CHECKS: readonly Check[] = [
-  {
-    id: 'gate',
-    runs: 'thread gate',
-    because: 'every step this tree declares, in the order it declares them, which is where the descent and the sweep are',
-  },
-]
-
-const PREFIX = /^(?:npx|pnpm)$/
-
-const words = (said: string): readonly string[] => said.split(/\s+/).filter((one) => one !== '')
-
-function run(given: readonly string[], extra?: Record<string, string>): number {
-  const mine = given[0] === 'thread' ? 1 : PREFIX.test(given[0] ?? '') && given[1] === 'thread' ? 2 : 0
-  const how = { at: ROOT, shows: true, within: STEP_TIMEOUT, holds: extra === undefined ? env : { ...env, ...extra } }
-  const went = mine === 0 ? starts(given[0] ?? '', given.slice(1), how) : starts(execPath, [...CLI, ...given.slice(mine)], how)
-  return went.there ? went.code : 1
-}
-
-function refuse(id: string, code: number, because: string, runs: string): never {
-  stderr.write(`\npublish: REFUSED — \`${id}\` exited ${String(code)}. NOTHING was published.\n`)
-  stderr.write(`publish: ${because}.\n`)
-  stderr.write(`publish: what refused is above, in that command's own words — this does not restate it, because a\n`)
-  stderr.write(`publish: second copy of a refusal drifts from the first. Run \`${runs}\` alone to work on it.\n`)
-  exit(1)
-}
-
-const given = argv.indexOf('--registry')
-
-if (given !== -1) {
-  stderr.write('thread publish   takes no url. Where the packages go is the address on the ht_registry row in _threads/targets.ts.\n')
-  stderr.write('\nit builds, then runs every check, then publishes. A check that fails publishes nothing.\n')
-  exit(1)
-}
-
-const TOKEN = 'sec_registry_token'
-
-const PRODUCTION = 'production'
-
-const secrets = inTree(TREE, 'secrets.ts')
-
-const declared = existsSync(secrets)
-  ? ((valuesIn(readFileSync(secrets)) as { SECRETS?: readonly Secret[] }).SECRETS ?? [])
-  : []
-
-const vaulted = declared.some((one) => one.id === TOKEN)
-
-const targets = inTree(TREE, 'targets.ts')
-
-const registry = placedAt(
-  existsSync(targets) ? ((valuesIn(readFileSync(targets)) as { TARGETS?: readonly Target[] }).TARGETS ?? []) : [],
-  REGISTRY,
-).replace(/[/]$/, '')
-
-if (registry === '') {
-  stderr.write('\npublish: no target row says where the registry is, so there is nowhere for these packages to go. Give ' + REGISTRY + ' an address in _threads/targets.ts, the absolute url of the registry. NOTHING was published.\n')
-  exit(1)
-}
-
-if (vaulted && !sealedIn(ROOT, PRODUCTION).includes(TOKEN)) {
-  stderr.write(`\npublish: ${TOKEN} is declared in _threads/secrets.ts and has no value sealed for ${PRODUCTION}, so nothing was checked and NOTHING was published.\n`)
-  stderr.write(`publish: run \`thread create secret set ${TOKEN}\` at a terminal and paste the registry token, or take the row out to publish with the login this machine holds.\n`)
-  exit(1)
-}
-
-const setting = (): string => {
-  const at = new URL(registry)
-  return `npm_config_//${at.host}${at.pathname.endsWith('/') ? at.pathname : `${at.pathname}/`}:_authToken`
-}
-
-async function tokened(): Promise<string> {
-  const values = await opened(ROOT, declared.map((one) => one.id), PRODUCTION)([TOKEN]).catch((thrown: unknown) => {
-    stderr.write(`\npublish: ${TOKEN} is sealed here and would not open: ${thrown instanceof Error ? thrown.message : String(thrown)}. NOTHING was published.\n`)
-    exit(1)
-  })
-  const token = values[TOKEN]
-  if (token === undefined) {
-    stderr.write(`\npublish: the vault opened and answered nothing for ${TOKEN}. NOTHING was published.\n`)
-    exit(1)
-  }
-  return token
-}
-
-const signedAs = env['GITHUB_ACTIONS'] === 'true' ? 'the identity npm trusts this GitHub Actions run under' : 'the login this machine already holds'
-
-stdout.write(
-  vaulted
-    ? `publish: ${TOKEN} is declared and sealed for ${PRODUCTION}. It is opened only after every check passes, and handed to pnpm as its auth setting for ${registry}.\n`
-    : `publish: no row declares ${TOKEN}, so this publish uses ${signedAs}. Declare it with \`thread create secret\` to publish with a token sealed in this repository instead.\n`,
-)
-
-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(words(`${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',
-    `${TYPED} packaged --build`,
-  )
-}
-
-stdout.write(`\npublish: ${String(CHECKS.length)} check(s) stand between this tree and ${registry}. Any one of them stops it.\n`)
-for (const check of CHECKS) stdout.write(`  ${check.id} — ${check.runs}\n`)
-
-for (const [index, check] of CHECKS.entries()) {
-  const at = `check ${String(index + 1)} of ${String(CHECKS.length)}`
-  stdout.write(`\npublish: ${at} — ${check.runs} (${check.id})\n`)
-
-  const code = run(words(check.runs))
-  stdout.write(`publish: ${at} — exited ${String(code)}\n`)
-  if (code !== 0) refuse(check.id, code, check.because, check.runs)
-}
-
-const numbered = run(words(`${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',
-    `${TYPED} packaged --release`,
-  )
-}
-
-const handed = vaulted ? { [setting()]: await tokened() } : undefined
-
-stdout.write(`\npublish: every check passed. Publishing to ${registry} with ${vaulted ? `${TOKEN} from this repository's vault` : signedAs}.\n`)
-
-const sent = run(words(`pnpm -r publish --registry ${registry} --no-git-checks --access public`), handed)
-
-if (sent !== 0) {
-  stderr.write(`\npublish: the checks passed and the publish itself exited ${String(sent)}.\n`)
-  const back = run(words(`${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 \`${TYPED} packaged\` to put the last recorded release back.\n`,
-  )
-  exit(1)
-}
-
-const recorded = run(words(`${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 \`${TYPED} packaged --record\` and read what it says.\n`)
-  exit(1)
-}
-
-const SHEET = 'packaging.ts'
-
-interface Packaged {
-  readonly id?: string
-  readonly folder?: string
-}
-
-const sheet = inTree(TREE, SHEET)
-
-const stated = existsSync(sheet)
-  ? (valuesIn(readFileSync(sheet)) as { PACKAGES?: readonly Packaged[] })
-  : {}
-
-const shipped = stated.PACKAGES ?? []
-
-function versionAt(folder: string): string {
-  const at = join(ROOT, folder, 'package.json')
-  if (!existsSync(at)) return 'no manifest'
-  try {
-    return (JSON.parse(readFileSync(at, 'utf8')) as { version?: string }).version ?? 'no version'
-  } catch {
-    return 'no version'
-  }
-}
-
-const git = calls('cli_git', ROOT)
-
-const asked = async (what: readonly string[]): Promise<string> => (await git.rev_parse(what)).out.trim()
-
-if ((await asked(['--is-inside-work-tree'])) !== 'true') {
-  stdout.write("\npublish: it's not a repo, so nothing was committed.\n")
-} else if (shipped.length === 0) {
-  stdout.write('\npublish: no packaging row names a folder, so there is nothing derived here to commit.\n')
-} else {
-  const going = shipped.map((one) => `${named(one.id ?? '')} ${versionAt(one.folder ?? '')}`).join(', ')
-  const branch = await asked(['--abbrev-ref', 'HEAD'])
-
-  for (const one of shipped) await git.stage([one.folder ?? ''], true, STEP_TIMEOUT)
-
-  if ((await git.diff(['--cached', '--quiet'])).ok) {
-    stdout.write(`\npublish: ${going} — what is on disk is already what is committed, so this release added no artifact.\n`)
-  } else {
-    const wrote = (await git.commit(['-m', `thread publish — ${going}`], true, STEP_TIMEOUT)).code
-    stdout.write(`publish: commit exited ${String(wrote)}\n`)
-    if (wrote !== 0) {
-      stderr.write('\npublish: the packages went out and the files that describe them are not committed, so this release has no record in git.\n')
-      stderr.write('publish: commit them by hand — everything is staged.\n')
-      exit(1)
-    }
-    stdout.write(`publish: committed the derived artifacts to ${branch} — ${going}.\n`)
-  }
-}
-
-stdout.write(`\npublish: done. What went out was derived, then built, then passed the gate, in that order. The compile inside \`thread packaged --build\` is the typecheck.\n`)
-exit(0)

package/dist/integrity/generators/trial.ts

@@ -1,359 +0,0 @@
-import { answeredBy, standing } from '../../integrations/disk.ts'
-import { resolve } from 'node:path'
-
-import type { Linter as LinterType, Rule } from 'eslint'
-import { Linter } from 'eslint'
-
-import type { Constraint, Proof, Sourced } from '../constraint.ts'
-
-const TREE = findTree()
-import { NOT_WRITTEN, ROOT, governs, proofsOf, reads, slopnatorName, sweeps, visits, type Slopnator } from '../slopnator.ts'
-import { forget } from '../slopnators/sl_unthreaded.ts'
-import { findTree } from '../../core/tree.ts'
-
-const PROBE = 'probe.tsx'
-
-const WRAPPINGS: readonly ((source: string) => string)[] = [
-  (source) => source,
-  (source) => `const _probe = { ${source} }`,
-  (source) => `const _probe = <Probe ${source} />`,
-  (source) => `const _probe = () => { ${source} }`,
-  (source) => `const _probe = <Probe>{${source}}</Probe>`,
-]
-
-export interface Scenario {
-  readonly files: readonly Sourced[]
-  readonly at: string
-}
-
-export interface Trial {
-  readonly id: string
-  readonly rule: string
-  readonly name: string
-  readonly scenario: Scenario
-  readonly verdict: { readonly reports: boolean }
-  readonly requires: string
-}
-
-export interface Derivation {
-  readonly trials: readonly Trial[]
-}
-
-export interface Outcome {
-  readonly id: string
-  readonly rule: string
-  readonly passed: boolean
-  readonly failures: readonly string[]
-  readonly parsed: boolean
-}
-
-export interface Run {
-  readonly outcomes: readonly Outcome[]
-  readonly passed: number
-  readonly failed: number
-  readonly measured: number
-  readonly spent: ReadonlyMap<string, number>
-}
-
-const canonical = (at: string): string => at.replace(/^threads\//, `${TREE.name}/`)
-
-export function probeAt(rule: Constraint): string {
-  const path = canonical(rule.where.paths[0] ?? 'src/')
-  if (path === '.') return PROBE
-  return path.endsWith('/') ? `${path}${PROBE}` : `${path}/${PROBE}`
-}
-
-function requiresOf(rule: Constraint, reports: boolean): string {
-  return reports
-    ? `${rule.id} reports on this source, at a path it governs`
-    : `${rule.id} stays silent on this source — the fix it recommends is not itself refused`
-}
-
-function scenarioOf(rule: Constraint, proof: Proof): Scenario {
-  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 }
-}
-
-function spoken(scenario: Scenario): string {
-  const target = scenario.files.find((file) => file.at === scenario.at) ?? scenario.files[0]
-  const rest = scenario.files.length - 1
-  return `${target?.source ?? ''}${rest > 0 ? ` (beside ${String(rest)} more file(s))` : ''}`
-}
-
-export function deriveTrials(all: readonly Constraint[], slopnators: ReadonlyMap<string, Slopnator>): Derivation {
-  const trials: Trial[] = []
-
-  for (const rule of all) {
-    const proofs = proofsOf(rule, slopnators)
-    const put = (proof: Proof, index: number, reports: boolean): void => {
-      const scenario = scenarioOf(rule, proof)
-      trials.push({
-        id: `trl_rule_${rule.id.replace(/-/g, '_')}_${reports ? 'refuses' : 'accepts'}_${String(index)}`,
-        rule: rule.id,
-        name: `${rule.id} ${reports ? 'refuses' : 'accepts'}: ${spoken(scenario)}`,
-        scenario,
-        verdict: { reports },
-        requires: requiresOf(rule, reports),
-      })
-    }
-    proofs.wrong.forEach((proof, index) => { put(proof, index, true) })
-    proofs.right.forEach((proof, index) => { put(proof, index, false) })
-  }
-
-  return { trials: trials.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) }
-}
-
-function config(rule: Constraint, module: Rule.RuleModule, parser: unknown): Parameters<LinterType['verify']>[1] {
-  return [
-    {
-      files: ['**/*.ts', '**/*.tsx'],
-      languageOptions: {
-        parser,
-        parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
-      },
-      plugins: { rule: { rules: { [rule.id]: module } } },
-      rules: { [`rule/${rule.id}`]: 'error' },
-    },
-  ] as unknown as Parameters<LinterType['verify']>[1]
-}
-
-export function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule, parser: unknown, slopnator?: Slopnator): Outcome {
-  const linter = new Linter()
-  const failures: string[] = []
-
-  if (!governs(rule, trial.scenario.at)) {
-    return {
-      id: trial.id,
-      rule: rule.id,
-      passed: false,
-      parsed: false,
-      failures: [`the trial's own path "${trial.scenario.at}" is not one the rule governs, so nothing could have run`],
-    }
-  }
-
-  const target = trial.scenario.files.find((file) => file.at === trial.scenario.at)
-
-  let parsed = false
-  let satisfied = false
-
-  answeredBy(standing(ROOT, new Map<string, string>(trial.scenario.files.map((one) => [resolve(ROOT, one.at), one.source]))))
-  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,
-        text: target.source,
-        ancestors: () => [],
-        comments: () => [],
-      })
-      parsed = true
-      satisfied = (held !== false && held !== NOT_WRITTEN) === trial.verdict.reports
-    } else {
-      for (const wrap of WRAPPINGS) {
-        const text = wrap(target.source)
-        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/${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 {
-    answeredBy(undefined)
-    forget()
-  }
-
-  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 (failures.length === 0 && !satisfied) {
-    failures.push(
-      trial.verdict.reports
-        ? `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 }
-}
-
-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[],
-  rules: Readonly<Record<string, Rule.RuleModule>>,
-  parser: unknown,
-  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]
-    if (rule === undefined || module === undefined) {
-      return {
-        id: trial.id,
-        rule: trial.rule,
-        passed: false,
-        parsed: false,
-        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\``],
-      }
-    }
-    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 {
-    outcomes,
-    passed: outcomes.filter((outcome) => outcome.passed).length,
-    failed: outcomes.filter((outcome) => !outcome.passed).length,
-    measured: outcomes.filter((outcome) => outcome.parsed).length,
-    spent,
-  }
-}
-