@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/slopnators/sl_derived_drift.ts

@@ -1,101 +0,0 @@
-import { readFileSync } from '../../integrations/disk.ts'
-import { resolve } from 'node:path'
-
-import type { Slopnator } from '../slopnator.ts'
-import { atsIn } from './sl_unthreaded.ts'
-import { reached } from '../../core/descend.ts'
-
-export interface Derivation {
-  readonly at: string
-  readonly by?: string
-  readonly runs?: string
-}
-
-export function derivations(root: string): readonly Derivation[] {
-  const found: Derivation[] = []
-  for (const at of reached()) {
-    let text: string
-    try {
-      text = readFileSync(resolve(root, at), 'utf8')
-    } catch {
-      continue
-    }
-    const threadedDerives = new Set(atsIn(text, new Set(['derives'])))
-    for (const opens of text.matchAll(/^\s*derives:\s*\[/gm)) {
-      const from = opens.index ?? 0
-      let depth = 1
-      let cursor = from + opens[0].length
-      while (cursor < text.length && depth > 0) {
-        const one = text[cursor]
-        if (one === '[') depth += 1
-        else if (one === ']') depth -= 1
-        cursor += 1
-      }
-      const own: string[] = []
-      let nesting = 0
-      for (const line of text.slice(from, cursor).split('\n')) {
-        if (nesting === 1) own.push(line)
-        for (const one of line) {
-          if (one === '[') nesting += 1
-          else if (one === ']') nesting -= 1
-        }
-      }
-      const block = own.join('\n')
-      for (const row of block.split(/^\s*\{$/m)) {
-        const at = /^\s*at:\s*'([^']+)'/m.exec(row)?.[1]
-        const by = /^\s*by:\s*'([^']+)'/m.exec(row)?.[1]
-        const runs = /^\s*runs:\s*'([^']+)'/m.exec(row)?.[1]
-        if (at !== undefined && threadedDerives.has(at)) found.push({ at, by, runs })
-      }
-    }
-  }
-  return found
-}
-
-export const slopnator: Slopnator = {
-  checks: (root) => {
-    const findings: string[] = []
-    const all = derivations(root)
-    const complete = all.filter((one) => one.by !== undefined && one.runs !== undefined)
-    const covered = new Set(complete.map((one) => one.at))
-
-    for (const at of new Set(all.map((one) => one.at))) {
-      if (covered.has(at)) continue
-      findings.push(
-        `${at} sits in a \`derives\` list and no row naming it states both \`by\` and \`runs\` — a byproduct nothing can re-run is a claim, and this check used to drop such a row in silence`,
-      )
-    }
-
-    return findings
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_drift_probe.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_drift_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/_generated/gate.mjs',\n      by: 'pnpm gate:generate',\n    },\n  ],\n}\n" },
-        ],
-        at: 'threads/_drift_probe.ts',
-      },
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-            { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_drift_probe.ts',\n    },\n  ],\n}\n" },
-            { at: 'threads/_drift_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}\n" },
-        ],
-        at: 'threads/_drift_probe.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-            { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_drift_probe.ts',\n    },\n  ],\n}\n" },
-            { at: 'threads/_drift_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/_generated/gate.mjs',\n      by: 'pnpm gate:generate',\n      runs: 'pnpm gate:check',\n    },\n  ],\n}\n" },
-        ],
-        at: 'threads/_drift_probe.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_door_in_a_node.ts

@@ -1,250 +0,0 @@
-import { resolve } from 'node:path'
-
-import ts from 'typescript'
-
-import { ROOT, configured, hosting } from '../../core/descend.ts'
-import { kind, readFileSync } from '../../integrations/disk.ts'
-import { OPENS } from '../../integrations/target.ts'
-
-import type { Slopnator } from '../slopnator.ts'
-import { here } from './sl_unthreaded.ts'
-
-const IMPORTED = 'import '
-
-const MADE = 'new '
-
-const RUNTIME = 'node:'
-
-const ANYWHERE = 'globalThis'
-
-const REQUIRED = 'require'
-
-const DECLARED = /\.d\.([cm]?)ts$/
-
-const READABLE = /\.(?:[cm]?[jt]s|[jt]sx)$/
-
-const plain = (specifier: string): string => (specifier.startsWith(RUNTIME) ? specifier.slice(RUNTIME.length) : specifier)
-
-interface Door {
-  readonly reach: string
-  readonly spelling: string
-}
-
-interface Doors {
-  readonly modules: ReadonlyMap<string, Door>
-  readonly globals: ReadonlyMap<string, Door>
-  readonly properties: ReadonlyMap<string, Door>
-}
-
-function doors(): Doors {
-  const modules = new Map<string, Door>()
-  const globals = new Map<string, Door>()
-  const properties = new Map<string, Door>()
-  for (const [reach, spellings] of Object.entries(OPENS)) {
-    for (const spelling of spellings) {
-      const door = { reach, spelling }
-      if (spelling.startsWith(IMPORTED)) {
-        const rest = spelling.slice(IMPORTED.length)
-        const dot = rest.lastIndexOf('.')
-        modules.set(plain(dot === -1 || rest.slice(dot).includes('/') ? rest : rest.slice(0, dot)), door)
-        continue
-      }
-      if (spelling.startsWith(MADE)) {
-        globals.set(spelling.slice(MADE.length), door)
-        continue
-      }
-      if (spelling.includes('.')) properties.set(spelling, door)
-      else globals.set(spelling, door)
-    }
-  }
-  return { modules, globals, properties }
-}
-
-const DOORS = doors()
-
-interface Brought {
-  readonly specifier: string
-  readonly line: number
-}
-
-const files = new Map<string, ts.SourceFile>()
-
-function parsed(at: string, text: string): ts.SourceFile {
-  const held = files.get(text)
-  if (held !== undefined) return held
-  const file = ts.createSourceFile(at, text, ts.ScriptTarget.Latest, true, at.endsWith('x') ? ts.ScriptKind.TSX : ts.ScriptKind.TS)
-  files.set(text, file)
-  return file
-}
-
-function brought(file: ts.SourceFile): readonly Brought[] {
-  const found: Brought[] = []
-  const line = (node: ts.Node): number => file.getLineAndCharacterOfPosition(node.getStart(file)).line + 1
-  const visit = (node: ts.Node): void => {
-    if (ts.isImportDeclaration(node) && node.importClause?.isTypeOnly !== true && ts.isStringLiteral(node.moduleSpecifier)) {
-      found.push({ specifier: node.moduleSpecifier.text, line: line(node) })
-    }
-    if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier)) {
-      found.push({ specifier: node.moduleSpecifier.text, line: line(node) })
-    }
-    if (ts.isCallExpression(node)) {
-      const first = node.arguments[0]
-      const loads = node.expression.kind === ts.SyntaxKind.ImportKeyword || (ts.isIdentifier(node.expression) && node.expression.text === REQUIRED)
-      if (loads && first !== undefined && ts.isStringLiteral(first)) found.push({ specifier: first.text, line: line(node) })
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(file)
-  return found
-}
-
-const binds = (node: ts.Identifier): boolean => {
-  const parent = node.parent
-  return (
-    (ts.isVariableDeclaration(parent) ||
-      ts.isParameter(parent) ||
-      ts.isBindingElement(parent) ||
-      ts.isFunctionDeclaration(parent) ||
-      ts.isClassDeclaration(parent) ||
-      ts.isImportSpecifier(parent) ||
-      ts.isImportClause(parent) ||
-      ts.isNamespaceImport(parent)) &&
-    parent.name === node
-  )
-}
-
-const named = (node: ts.Node): boolean => (node.parent as { readonly name?: ts.Node } | undefined)?.name === node
-
-const opened = new Map<string, Door | undefined>()
-
-function opening(at: string, text: string): Door | undefined {
-  if (opened.has(text)) return opened.get(text)
-  const file = parsed(at, text)
-  let found: Door | undefined
-  for (const one of brought(file)) found ??= DOORS.modules.get(plain(one.specifier))
-  const bound = new Set<string>()
-  const collect = (node: ts.Node): void => {
-    if (ts.isIdentifier(node) && binds(node)) bound.add(node.text)
-    ts.forEachChild(node, collect)
-  }
-  collect(file)
-  const visit = (node: ts.Node): void => {
-    if (found !== undefined) return
-    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && !ts.isPartOfTypeNode(node)) {
-      const object = node.expression.text
-      found = DOORS.properties.get(object + '.' + node.name.text) ?? (object === ANYWHERE ? DOORS.globals.get(node.name.text) : undefined)
-    }
-    if (found === undefined && ts.isIdentifier(node) && !named(node) && !ts.isPartOfTypeNode(node) && !bound.has(node.text)) {
-      found = DOORS.globals.get(node.text)
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(file)
-  opened.set(text, found)
-  return found
-}
-
-let options: ts.CompilerOptions | undefined
-
-let host: ts.CompilerHost | undefined
-
-function resolvedOf(specifier: string, from: string): string | undefined {
-  options ??= configured().options
-  host ??= hosting(options)
-  const found = ts.resolveModuleName(specifier, from, options, host).resolvedModule
-  if (found === undefined) return undefined
-  const at = found.resolvedFileName
-  if (!DECLARED.test(at)) return at
-  const emitted = at.replace(DECLARED, '.$1js')
-  return kind(emitted) === 'file' ? emitted : undefined
-}
-
-const readable = (at: string): string | undefined => (READABLE.test(at) && kind(at) === 'file' ? readFileSync(at, 'utf8') : undefined)
-
-const shown = (chain: readonly string[], door: Door): string =>
-  chain.map((one) => '`' + one + '`').join(', which imports ') +
-  (door.spelling.startsWith(IMPORTED) ? ', which imports ' + door.spelling.slice(IMPORTED.length) : ', which reaches ' + door.spelling) +
-  ' — the ' +
-  door.reach +
-  ' reach, and no target declares it. Nothing prices that reach, replays it in a trial or refuses it. Declare the place with `thread create target`, require it on the operation, and call what the node is handed instead'
-
-function through(at: string, chain: readonly string[], seen: Set<string>): string | undefined {
-  const text = readable(at)
-  if (text === undefined) return undefined
-  const door = opening(at, text)
-  if (door !== undefined) return shown(chain, door)
-  for (const one of brought(parsed(at, text))) {
-    const next = resolvedOf(one.specifier, at)
-    if (next === undefined || seen.has(next)) continue
-    seen.add(next)
-    const found = through(next, [...chain, one.specifier], seen)
-    if (found !== undefined) return found
-  }
-  return undefined
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-    if (!READABLE.test(path)) return false
-    const from = resolve(ROOT, path)
-    const seen = new Set<string>([from])
-    for (const one of brought(parsed(from, at.text))) {
-      const next = resolvedOf(one.specifier, from)
-      if (next === undefined || seen.has(next)) continue
-      seen.add(next)
-      const found = through(next, [one.specifier], seen)
-      if (found !== undefined) return 'line ' + String(one.line) + ': imports ' + found
-    }
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'thread/integrations/cli.ts', source: "import { spawn } from 'node:child_process'\n\nexport const starts = (program: string): void => {\n  spawn(program)\n}\n" },
-          { at: 'operations/_probe_node.ts', source: "export { starts } from '../thread/integrations/cli.ts'\n" },
-        ],
-        at: 'operations/_probe_node.ts',
-      },
-      {
-        files: [
-          { at: 'thread/integrations/https.ts', source: "export const sendingHttp = async (address: string): Promise<number> => (await fetch(address)).status\n" },
-          { at: 'src/_probe_helper.ts', source: "import { sendingHttp } from '../thread/integrations/https.ts'\n\nexport const status = (address: string): Promise<number> => sendingHttp(address)\n" },
-          { at: 'operations/_probe_node.ts', source: "import { status } from '../src/_probe_helper.ts'\n\nexport const node = (address: string): Promise<number> => status(address)\n" },
-        ],
-        at: 'operations/_probe_node.ts',
-      },
-      {
-        files: [
-          { at: 'thread/integrations/disk.ts', source: "import * as disk from 'node:fs'\n\nexport const read = (at: string): string => disk.readFileSync(at, 'utf8')\n" },
-          { at: 'operations/_probe_node.ts', source: "export const node = async (at: string): Promise<string> => (await import('../thread/integrations/disk.ts')).read(at)\n" },
-        ],
-        at: 'operations/_probe_node.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          { at: 'thread/operations/nodes.ts', source: "export const nd_action = <T>(run: T): T => run\n" },
-          { at: 'operations/_probe_node.ts', source: "import { nd_action } from '../thread/operations/nodes.ts'\n\nexport const node = nd_action(async () => 1)\n" },
-        ],
-        at: 'operations/_probe_node.ts',
-      },
-      {
-        files: [
-          { at: 'thread/integrations/cli.ts', source: "import { spawn } from 'node:child_process'\n\nexport interface Ran {\n  readonly out: string\n}\n\nexport const starts = (program: string): void => {\n  spawn(program)\n}\n" },
-          { at: 'operations/_probe_node.ts', source: "import type { Ran } from '../thread/integrations/cli.ts'\n\nexport const node = (ran: Ran): string => ran.out\n" },
-        ],
-        at: 'operations/_probe_node.ts',
-      },
-      {
-        files: [
-          { at: 'src/_probe_helper.ts', source: "const fetch = (said: string): string => said\n\nexport const shout = (said: string): string => fetch(said).toUpperCase()\n" },
-          { at: 'operations/_probe_node.ts', source: "import { shout } from '../src/_probe_helper.ts'\n\nexport const node = (): string => shout('a')\n" },
-        ],
-        at: 'operations/_probe_node.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_hardcoded_style.ts

@@ -1,55 +0,0 @@
-import ts from 'typescript'
-
-
-import type { Slopnator } from '../slopnator.ts'
-
-const ALONE = /^\s*([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\s*:\s*([^;{}\n]+);\s*$/
-
-const NAMED = /var\(\s*--/
-
-const PIECES = new Set([
-  ts.SyntaxKind.StringLiteral,
-  ts.SyntaxKind.NoSubstitutionTemplateLiteral,
-  ts.SyntaxKind.TemplateHead,
-  ts.SyntaxKind.TemplateMiddle,
-  ts.SyntaxKind.TemplateTail,
-])
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.JSX, at.text)
-    let token = scanner.scan()
-    while (token !== ts.SyntaxKind.EndOfFileToken) {
-      if (PIECES.has(token)) {
-        const said = scanner.getTokenValue()
-        const found = ALONE.exec(said)
-        if (found !== null) {
-          const property = found[1] ?? ''
-          const value = (found[2] ?? '').trim()
-          if (value !== '' && !NAMED.test(value)) {
-            return (
-              `\`${property}\` is written into the compiler with \`${value}\` typed into it, so a ` +
-              'stylesheet carries a decision nothing declared — no rebrand moves it, no mode or theme reaches it, and no sheet knows it is there'
-            )
-          }
-        }
-      }
-      token = scanner.scan()
-    }
-    return false
-  },
-  proves: {
-    wrong: [
-      "lines.push('  body {', '    background: #f8fbfa;', '  }')",
-      "classes.push('    padding: 8px 16px;')",
-      "return ['  :where(*) {', '    text-box-trim: trim-both;', '  }']",
-      "held.push('    color-scheme: light dark;')",
-    ],
-    right: [
-      "lines.push('  body {', '    background: var(--colour-page);', '  }')",
-      'lines.push(...block(selector, made, indent))',
-      'held.push(`    ${nameOf(id)}: ${made[id] ?? String()};`)',
-      'const held: readonly string[] = [];',
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_inert_island.ts

@@ -1,84 +0,0 @@
-import { existsSync, readFileSync } from '../../integrations/disk.ts'
-import { resolve } from 'node:path'
-
-import type { Slopnator } from '../slopnator.ts'
-import { declaresIsland, here, rowsIn } from './sl_unthreaded.ts'
-import { findTree } from '../../core/tree.ts'
-
-const ROOT = findTree().at
-const TREE = `${findTree().name}/`
-
-function schemaAt(at: string): string | undefined {
-  const path = resolve(ROOT, at)
-  if (!existsSync(path)) return undefined
-  try {
-    return declaresIsland(readFileSync(path, 'utf8'))
-  } catch {
-    return undefined
-  }
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-    if (!path.startsWith(TREE)) return false
-
-    let rows
-    try {
-      rows = rowsIn(at.text)
-    } catch {
-      return 'this file cannot be parsed, so the islands it declares were never read and nothing about what they govern was measured'
-    }
-
-    for (const row of rows) {
-      if (row.at === undefined || row.id === undefined) continue
-      const schema = schemaAt(row.at)
-      if (schema === undefined) continue
-      if ((row.governs ?? []).length > 0) continue
-      return (
-        `island "${row.id}" states nothing it governs, so ${schema}IslandSchema is a shape nothing is held to — ` +
-        'no file is the place its kind is declared, which makes every file the place, and the island is inert'
-      )
-    }
-
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'threads/_inert_probe.ts', source: "export const M: Threaded = {\n  declares: [\n    { id: 'entities', at: 'src/islands/entities.ts' },\n  ],\n}\n" },
-          { at: 'src/islands/entities.ts', source: 'export const EntitiesIslandSchema = {}\n' },
-        ],
-        at: 'threads/_inert_probe.ts',
-      },
-      {
-        files: [
-          { at: 'threads/_inert_probe.ts', source: "export const M: Threaded = {\n  declares: [\n    { id: 'events', at: 'src/islands/events.ts', governs: [] },\n  ],\n}\n" },
-          { at: 'src/islands/events.ts', source: 'export const EventsIslandSchema = {}\n' },
-        ],
-        at: 'threads/_inert_probe.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly governs?: readonly string[]\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_inert_probe.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_inert_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    { id: 'events', at: 'src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n" },
-          { at: 'src/islands/events.ts', source: 'export const EventsIslandSchema = {}\n' },
-        ],
-        at: 'threads/_inert_probe.ts',
-      },
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_inert_probe.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_inert_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    { id: 'a-file', at: 'threads/_plain.ts' },\n  ],\n}\n" },
-          { at: 'threads/_plain.ts', source: 'export const PLAIN = 1\n' },
-        ],
-        at: 'threads/_inert_probe.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_inert_slopnator.ts

@@ -1,93 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-
-interface Node {
-  readonly type?: string
-  readonly name?: string
-  readonly key?: { readonly name?: string; readonly value?: unknown }
-  readonly value?: unknown
-  readonly body?: unknown
-  readonly properties?: readonly Node[]
-  readonly elements?: readonly unknown[]
-}
-
-const keyOf = (node: Node): string | undefined =>
-  node.key?.name ?? (typeof node.key?.value === 'string' ? node.key.value : undefined)
-
-const answersUnwritten = (held: unknown): boolean => {
-  const fn = held as { type?: string; body?: { type?: string; name?: string } } | undefined
-  if (fn?.type !== 'ArrowFunctionExpression') return false
-  return fn.body?.type === 'Identifier' && fn.body.name === 'NOT_WRITTEN'
-}
-
-const statesNothing = (held: unknown): boolean => {
-  const proves = held as Node | undefined
-  if (proves?.type !== 'ObjectExpression') return false
-  return (proves.properties ?? []).some((one) => {
-    const key = keyOf(one)
-    if (key !== 'wrong' && key !== 'right') return false
-    const list = one.value as Node | undefined
-    return list?.type === 'ArrayExpression' && (list.elements ?? []).length === 0
-  })
-}
-
-export const slopnator: Slopnator = {
-  on: ['Property'],
-  holds: (node) => {
-    const held = node as Node
-    const key = keyOf(held)
-
-    if (key === 'holds' && answersUnwritten(held.value)) {
-      return 'this is still the scaffold — it answers `NOT_WRITTEN` to everything, so the rule that names it registers, loads, reports nothing, and reads from outside exactly like a rule being obeyed'
-    }
-
-    if (key === 'on') {
-      const list = held.value as Node | undefined
-      if (list?.type === 'ArrayExpression' && (list.elements ?? []).length === 0) {
-        return 'it says it visits syntax and then names no node type, so it is handed nothing and governs nothing inside the files its rule governs'
-      }
-    }
-
-    if (key === 'proves' && statesNothing(held.value)) {
-      return 'its `proves` states nothing — with no form it refuses and none it accepts, no trial is derived from it, so nothing anywhere shows the slopnator does what its row claims'
-    }
-
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          {
-            at: 'thread/integrity/slopnators/sl_probe_inert.ts',
-            source: 'export const slopnator = {\n  on: [],\n  holds: () => NOT_WRITTEN,\n  proves: { wrong: [], right: [] },\n}\n',
-          },
-        ],
-        at: 'thread/integrity/slopnators/sl_probe_inert.ts',
-      },
-      {
-        files: [
-          {
-            at: 'thread/integrity/slopnators/sl_probe_inert.ts',
-            source: "export const slopnator = {\n  holds: (_node, at) => at.text.includes('nope') && 'found',\n  proves: { wrong: [], right: ['const held = 1'] },\n}\n",
-          },
-        ],
-        at: 'thread/integrity/slopnators/sl_probe_inert.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          {
-            at: 'thread/integrity/slopnators/sl_probe_inert.ts',
-            source: "export const slopnator = {\n  holds: (_node, at) => at.text.includes('nope') && 'found',\n  proves: { wrong: ['nope'], right: ['const held = 1'] },\n}\n",
-          },
-        ],
-        at: 'thread/integrity/slopnators/sl_probe_inert.ts',
-      },
-      {
-        files: [{ at: 'thread/integrity/slopnators/sl_probe_inert.ts', source: 'export const held = 1\n' }],
-        at: 'thread/integrity/slopnators/sl_probe_inert.ts',
-      },
-    ],
-  },
-}