@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/slopnators/sl_undeclared_list.ts

@@ -1,358 +0,0 @@
-import { dirname, resolve } from 'node:path'
-
-import ts from 'typescript'
-
-import { readFileSync } from '../../integrations/disk.ts'
-
-import type { Slopnator, SlopnatorContext } from '../slopnator.ts'
-
-const LIST = 2
-
-interface Held {
-  readonly type?: string
-  readonly value?: unknown
-  readonly name?: string
-  readonly operator?: string
-  readonly elements?: readonly (Held | null)[]
-  readonly properties?: readonly (Held | null)[]
-  readonly arguments?: readonly Held[]
-  readonly init?: Held | null
-  readonly id?: { readonly type?: string; readonly name?: string }
-  readonly callee?: Held
-  readonly object?: Held
-  readonly property?: Held
-  readonly expression?: Held
-  readonly argument?: Held | null
-  readonly test?: Held | null
-  readonly consequent?: Held | null
-  readonly alternate?: Held | null
-  readonly body?: readonly (Held | null)[]
-}
-
-const WIDENED = 'TSAsExpression'
-
-function bare(held: Held | null | undefined): Held | undefined {
-  let one = held ?? undefined
-  while (one?.type === WIDENED) one = one.expression
-  return one
-}
-
-const spoken = (held: Held | null | undefined): boolean => {
-  const one = bare(held)
-  return one?.type === 'Literal' && typeof one.value === 'string'
-}
-
-const strings = (held: Held | null | undefined): boolean => {
-  const one = bare(held)
-  if (one?.type !== 'ArrayExpression') return false
-  const all = one.elements ?? []
-  return all.length >= LIST && all.every((each) => spoken(each) || woven(each))
-}
-
-const SPREAD = 'SpreadElement'
-
-function woven(held: Held | null | undefined): boolean {
-  const one = bare(held)
-  if (one?.type !== SPREAD) return false
-  let words = 0
-  let other = false
-  const walk = (node: unknown, seen: Set<unknown>): void => {
-    if (node === null || typeof node !== 'object' || seen.has(node)) return
-    seen.add(node)
-    if (Array.isArray(node)) {
-      for (const each of node) walk(each, seen)
-      return
-    }
-    const held = node as Held
-    if (held.type === 'Literal') {
-      if (typeof held.value === 'string') words += 1
-      else other = true
-      return
-    }
-    for (const [key, each] of Object.entries(node as Record<string, unknown>)) {
-      if (key !== BACK) walk(each, seen)
-    }
-  }
-  walk(one.argument, new Set())
-  return words > 0 && !other
-}
-
-function valued(held: Held): readonly Held[] {
-  const found: Held[] = []
-  for (const one of held.properties ?? []) {
-    if (one?.type === 'Property') found.push(one.value as Held)
-  }
-  return found
-}
-
-function tabled(held: Held | null | undefined, seen: Set<unknown>): boolean {
-  const one = bare(held)
-  if (one === undefined || one.type !== 'ObjectExpression' || seen.has(one)) return false
-  seen.add(one)
-  const all = valued(one)
-  if (all.filter((each) => spoken(each)).length >= LIST) return true
-  return all.some((each) => strings(each) || tabled(each, seen))
-}
-
-function drawn(held: Held): string | undefined {
-  if (held.type !== 'NewExpression' || held.callee?.type !== 'Identifier' || held.callee.name !== 'Set') return undefined
-  const only = held.arguments ?? []
-  if (only.length !== 1) return undefined
-  const call = bare(only[0])
-  const callee = call?.callee
-  if (call?.type !== 'CallExpression' || callee?.type !== 'MemberExpression') return undefined
-  if (callee.object?.type !== 'Identifier' || callee.object.name !== 'Object') return undefined
-  const asked = callee.property?.name
-  if (asked !== 'keys' && asked !== 'values') return undefined
-  const from = bare((call.arguments ?? [])[0])
-  return from?.type === 'Identifier' ? from.name : undefined
-}
-
-function adapted(node: ts.Node): Held | undefined {
-  if (ts.isAsExpression(node) || ts.isParenthesizedExpression(node)) {
-    const inner = adapted(node.expression)
-    return inner === undefined ? undefined : { type: WIDENED, expression: inner }
-  }
-  if (ts.isStringLiteral(node)) return { type: 'Literal', value: node.text }
-  if (ts.isSpreadElement(node)) return { type: SPREAD, argument: adapted(node.expression) ?? null }
-  if (ts.isCallExpression(node)) {
-    return { type: 'CallExpression', arguments: node.arguments.map((one) => adapted(one)).filter((one): one is Held => one !== undefined) }
-  }
-  if (ts.isArrayLiteralExpression(node)) {
-    return { type: 'ArrayExpression', elements: node.elements.map((one) => adapted(one) ?? null) }
-  }
-  if (ts.isObjectLiteralExpression(node)) {
-    const properties: Held[] = []
-    for (const one of node.properties) {
-      if (!ts.isPropertyAssignment(one)) continue
-      const value = adapted(one.initializer)
-      if (value !== undefined) properties.push({ type: 'Property', value })
-    }
-    return { type: 'ObjectExpression', properties }
-  }
-  return undefined
-}
-
-function parsed(at: string, text: string): ts.SourceFile {
-  return ts.createSourceFile(at, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
-}
-
-function brought(source: ts.SourceFile, name: string): string | undefined {
-  for (const statement of source.statements) {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue
-    const bindings = statement.importClause?.namedBindings
-    if (bindings === undefined || !ts.isNamedImports(bindings)) continue
-    if (!bindings.elements.some((one) => one.name.text === name)) continue
-    return statement.moduleSpecifier.text
-  }
-  return undefined
-}
-
-function elsewhere(at: SlopnatorContext, name: string): Held | undefined {
-  const specifier = brought(parsed(at.filename, at.text), name)
-  if (specifier === undefined || !specifier.startsWith('.')) return undefined
-  const path = resolve(dirname(at.filename), specifier)
-  let text: string
-  try {
-    text = readFileSync(path, 'utf8')
-  } catch {
-    return undefined
-  }
-  for (const statement of parsed(path, text).statements) {
-    if (!ts.isVariableStatement(statement)) continue
-    for (const one of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(one.name) || one.name.text !== name || one.initializer === undefined) continue
-      return adapted(one.initializer)
-    }
-  }
-  return undefined
-}
-
-function initOf(held: unknown, name: string, seen: Set<unknown>): Held | undefined {
-  if (held === null || typeof held !== 'object' || seen.has(held)) return undefined
-  seen.add(held)
-  if (Array.isArray(held)) {
-    for (const one of held) {
-      const found = initOf(one, name, seen)
-      if (found !== undefined) return found
-    }
-    return undefined
-  }
-  const node = held as Held
-  const init = node.init ?? undefined
-  if (node.type === 'VariableDeclarator' && node.id?.type === 'Identifier' && node.id.name === name && init !== undefined) return init
-  for (const [key, one] of Object.entries(held as Record<string, unknown>)) {
-    if (key === BACK) continue
-    const found = initOf(one, name, seen)
-    if (found !== undefined) return found
-  }
-  return undefined
-}
-
-function listed(init: Held | null | undefined, program: unknown, at: SlopnatorContext, through: ReadonlySet<string>): boolean {
-  const one = bare(init)
-  if (one === undefined) return false
-  if (strings(one)) return true
-  if (tabled(one, new Set())) return true
-  if (one.type === 'NewExpression' || one.type === 'CallExpression') {
-    const only = one.arguments ?? []
-    if (only.length === 1 && strings(only[0])) return true
-  }
-  const from = drawn(one)
-  if (from === undefined || through.has(from)) return false
-  const followed = new Set(through)
-  followed.add(from)
-  const here = initOf(program, from, new Set())
-  return listed(here ?? elsewhere(at, from), program, at, followed)
-}
-
-const asks = (held: Held | undefined, name: string): boolean => {
-  const callee = held?.callee
-  if (held?.type !== 'CallExpression' || callee?.type !== 'MemberExpression') return false
-  const on = bare(callee.object)
-  if (on?.type !== 'Identifier' || on.name !== name) return false
-  const said = callee.property?.name
-  return said === 'has' || said === 'includes'
-}
-
-const BACK = 'parent'
-
-function asking(held: unknown, name: string, seen: Set<unknown>): boolean {
-  if (held === null || typeof held !== 'object' || seen.has(held)) return false
-  seen.add(held)
-  if (Array.isArray(held)) return held.some((one) => asking(one, name, seen))
-  if (asks(held as Held, name)) return true
-  return Object.entries(held as Record<string, unknown>).some(([key, one]) => key !== BACK && asking(one, name, seen))
-}
-
-function consults(node: Held, name: string): boolean {
-  if (node.type === 'MemberExpression') {
-    const on = bare(node.object)
-    if (on?.type === 'Identifier' && on.name === name) return true
-  }
-  const callee = node.callee
-  if (node.type !== 'CallExpression' || callee?.type !== 'MemberExpression') return false
-  if (callee.object?.type !== 'Identifier' || callee.object.name !== 'Object') return false
-  const only = node.arguments ?? []
-  const from = bare(only[0])
-  return only.length === 1 && from?.type === 'Identifier' && from.name === name
-}
-
-function consulted(held: unknown, name: string, seen: Set<unknown>): boolean {
-  if (held === null || typeof held !== 'object' || seen.has(held)) return false
-  seen.add(held)
-  if (Array.isArray(held)) return held.some((one) => consulted(one, name, seen))
-  if (consults(held as Held, name)) return true
-  return Object.entries(held as Record<string, unknown>).some(([key, one]) => key !== BACK && consulted(one, name, seen))
-}
-
-function continues(held: Held | null | undefined): boolean {
-  if (held === null || held === undefined) return false
-  if (held.type === 'ContinueStatement') return true
-  if (held.type !== 'BlockStatement') return false
-  return (held.body ?? []).some((one) => one?.type === 'ContinueStatement')
-}
-
-const LEAVES = 'ReturnStatement'
-
-const THROWN = 'ThrowStatement'
-
-const leaving = (one: Held | null | undefined): boolean => one?.type === LEAVES || one?.type === THROWN
-
-function exits(held: Held | null | undefined): boolean {
-  if (held === null || held === undefined) return false
-  if (leaving(held)) return true
-  if (held.type !== 'BlockStatement') return false
-  return (held.body ?? []).some((one) => leaving(one))
-}
-
-function look(held: unknown, name: string, found: { gates: boolean; skips: boolean }, seen: Set<unknown>): void {
-  if (held === null || typeof held !== 'object' || seen.has(held)) return
-  seen.add(held)
-  if (Array.isArray(held)) {
-    for (const one of held) look(one, name, found, seen)
-    return
-  }
-  const node = held as Held
-  if (node.type === 'UnaryExpression' && node.operator === '!' && asks(node.argument ?? undefined, name)) {
-    found.skips = true
-    return
-  }
-  if (node.type === 'IfStatement' && continues(node.consequent) && asking(node.test, name, new Set())) {
-    found.skips = true
-    look(node.consequent, name, found, seen)
-    look(node.alternate, name, found, seen)
-    return
-  }
-  if (node.type === 'IfStatement' && exits(node.consequent) && asking(node.test, name, new Set())) {
-    found.gates = true
-    return
-  }
-  if (asks(node, name)) {
-    found.gates = true
-    return
-  }
-  for (const [key, one] of Object.entries(node as Record<string, unknown>)) {
-    if (key !== BACK) look(one, name, found, seen)
-  }
-}
-
-export const slopnator: Slopnator = {
-  on: ['VariableDeclarator'],
-  holds: (node, at) => {
-    const held = node as Held
-    const program = at.ancestors().find((one) => (one as Held | undefined)?.type === 'Program')
-    if (!listed(held.init, program, at, new Set<string>())) return false
-    const named = held.id?.type === 'Identifier' ? held.id.name : undefined
-    const table = bare(held.init)?.type === 'ObjectExpression'
-    if (table && (named === undefined || !consulted(program, named, new Set()))) return false
-    if (named !== undefined) {
-      const found = { gates: false, skips: false }
-      look(program, named, found, new Set())
-      if (!found.gates && found.skips) return false
-    }
-    return (
-      `\`${named ?? 'this'}\` is ${table ? 'a table' : 'a list'} of words written out here and this check refuses what is IN it, so ` +
-      'whatever breaks the rule under a name nobody typed walks straight past. Wrapping them in `as const`, nesting them under a key, ' +
-      'or building a set out of the keys leaves the same list one step further out of sight. A list that decides what a check CATCHES ' +
-      'has to come from the tree: `thread inspect <word>` names the row that coins any word you need, and a check that reads those ' +
-      'rows widens when the tree does. A list a check only SKIPS is left alone, because adding a word to one of those makes it ' +
-      'stricter and it can never go blind.'
-    )
-  },
-  proves: {
-    wrong: [
-      "const CROSSINGS = ['fetch', 'setTimeout', 'setInterval']",
-      "const STARTS = new Set(['node:child_process', 'child_process'])\nexport const opens = (from: string): boolean => {\n  if (!STARTS.has(from)) return false\n  return true\n}",
-      "const GLOBALS = new Set(['Date', 'performance', 'Math'])",
-      "const MOVES = new Set(['push', 'replace'])\nexport const moved = (one: string): boolean => MOVES.has(one)",
-      "const SURFACES = ['cli', 'api', 'mcp'] as const\nexport const surfaced = (one: string): boolean => (SURFACES as readonly string[]).includes(one)",
-      "const MOVING = { globals: ['window', 'globalThis'], histories: ['router', 'history'] }\nexport const moves = (one: string): boolean => MOVING.globals.includes(one)",
-      "const HANDED_BY = { postgres: 'store', pglite: 'store', https: 'http' }\nexport const handedBy = (reach: string): string => HANDED_BY[reach] ?? reach",
-      "const HANDS = { postgres: 'store', pglite: 'store' }\nconst PINS = new Set(Object.keys(HANDS))\nexport const pinned = (one: string): boolean => PINS.has(one)",
-      {
-        files: [
-          { at: 'threads/held.ts', source: "export const PINNED = { clock: ['Date.now', 'setTimeout'] }\n" },
-          { at: 'threads/slopnators/sl_probe_followed.ts', source: "import { PINNED } from '../held.ts'\n\nconst PINS = new Set(Object.keys(PINNED))\nexport const pinned = (one: string): boolean => PINS.has(one)\n" },
-        ],
-        at: 'threads/slopnators/sl_probe_followed.ts',
-      },
-    ],
-    right: [
-      'const CROSSINGS = declared()',
-      "const UNDER = 'operations/'",
-      "const COMMON = new Set(['a', 'the'])\nexport const words = (all: readonly string[]): readonly string[] => all.filter((one) => !COMMON.has(one))",
-      "const SKIP = new Set(['dist', 'node_modules'])\nexport function walk(names: readonly string[]): number {\n  let seen = 0\n  for (const name of names) {\n    if (SKIP.has(name)) continue\n    seen += 1\n  }\n  return seen\n}",
-      "const LEFT = ['dist', 'node_modules'] as const\nexport function walked(names: readonly string[]): number {\n  let seen = 0\n  for (const name of names) {\n    if ((LEFT as readonly string[]).includes(name)) continue\n    seen += 1\n  }\n  return seen\n}",
-      "export const SAYS = { cli: 'runs at a terminal', api: 'answers a request' }",
-      {
-        files: [
-          { at: 'threads/made.ts', source: "export const MADE = declared()\n" },
-          { at: 'threads/slopnators/sl_probe_derived.ts', source: "import { MADE } from '../made.ts'\n\nconst PICKED = new Set(Object.keys(MADE))\nexport const picked = (one: string): boolean => PICKED.has(one)\n" },
-        ],
-        at: 'threads/slopnators/sl_probe_derived.ts',
-      },
-      "export const slopnator = { on: ['CallExpression', 'NewExpression'], holds: () => false, proves: { wrong: ['new Date()'], right: ['const at = 1'] } }",
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_undeclared_node.ts

@@ -1,75 +0,0 @@
-import { dirname, join, normalize } from 'node:path'
-
-import type { Slopnator } from '../slopnator.ts'
-import { here, index, parses, unreadable } from './sl_unthreaded.ts'
-
-const SAID = /'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)"|`((?:[^`\\$]|\\.)*)`/g
-
-const RELATIVE = /^\.\.?\//
-
-const UNDER = 'nodes/'
-
-const slash = (one: string): string => one.split('\\').join('/')
-
-function nodeAt(said: string, from: string): string | undefined {
-  if (said === '') return undefined
-  const path = slash(normalize(RELATIVE.test(said) ? join(from, said) : said))
-  return path.startsWith(UNDER) ? path : undefined
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-    if (unreadable(path, at.text) !== undefined) return false
-    if (!parses(path)) return false
-
-    const declared = index().reached
-    const from = dirname(path)
-
-    for (const found of String(at.text).matchAll(SAID)) {
-      const named = nodeAt(found[1] ?? found[2] ?? found[3] ?? '', from)
-      if (named === undefined || declared.has(named)) continue
-
-      return (
-        `this reaches \`${named}\`, and the descent from the tree root never arrives there — so one of ` +
-        'its steps is a node nobody declared. An operation that takes a step nothing agreed to is doing ' +
-        'something this app never said it could do, and the flow reads as agreed the whole way down'
-      )
-    }
-
-    return false
-  },
-  proves: {
-    wrong: [
-      "import { node as ghost } from '../nodes/nd_ghost.ts'",
-      "const held = await import('../nodes/nd_ghost.ts')",
-      "const held = require('../nodes/nd_ghost.ts')",
-      "export { node as ghost } from '../nodes/nd_ghost.ts'",
-      "const AT = '../nodes/nd_ghost.ts'",
-      "import { node as invented } from 'nodes/nd_nowhere.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/_probe_nodes.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_probe_nodes.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const NODES: Threaded = {\n  id: 'nodes',\n  declares: [\n    {\n      id: 'read',\n      at: 'nodes/nd_read.ts',\n    },\n    {\n      id: 'action',\n      at: 'nodes/nd_action.ts',\n    },\n  ],\n}\n" },
-          { at: 'operations/_probe_read.ts', source: "import { node as read } from '../nodes/nd_read.ts'" },
-        ],
-        at: 'operations/_probe_read.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/_probe_nodes.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_probe_nodes.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const NODES: Threaded = {\n  id: 'nodes',\n  declares: [\n    {\n      id: 'read',\n      at: 'nodes/nd_read.ts',\n    },\n    {\n      id: 'action',\n      at: 'nodes/nd_action.ts',\n    },\n  ],\n}\n" },
-          { at: 'operations/_probe_multi.ts', source: "import { node as action } from '../nodes/nd_action.ts'\nimport { node as read } from '../nodes/nd_read.ts'" },
-        ],
-        at: 'operations/_probe_multi.ts',
-      },
-      "import { z } from 'zod'",
-      "import type { Operation } from '../../operations/operations.ts'",
-      "import type { Held } from '../../operations/nodes.ts'",
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_undeclared_operation.ts

@@ -1,257 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-
-import { descend, read, reached } from '../../core/descend.ts'
-
-import { rowsIn } from './sl_unthreaded.ts'
-
-const UNDER = 'operations/'
-
-const DISPATCH = 'dispatch'
-
-function declared(): ReadonlySet<string> {
-  const found = new Set<string>()
-
-  descend()
-
-  for (const at of reached()) {
-    const text = read(at)
-    if (text === undefined) continue
-
-    for (const one of rowsIn(text)) {
-      const where = one.at?.split('\\').join('/')
-      if (where === undefined || !where.includes(UNDER)) continue
-      if (one.id !== undefined) found.add(one.id)
-    }
-  }
-
-  return found
-}
-
-function bodies(): ReadonlySet<string> {
-  const found = new Set<string>()
-
-  descend()
-
-  for (const at of reached()) {
-    const text = read(at)
-    if (text === undefined) continue
-
-    for (const one of rowsIn(text)) {
-      const where = one.at?.split('\\').join('/')
-      if (where === undefined || !where.includes(UNDER)) continue
-      if (one.id !== undefined) found.add(where.replace(/\.[^./]+$/, ''))
-    }
-  }
-
-  return found
-}
-
-function declaring(): ReadonlySet<string> {
-  const found = new Set<string>()
-
-  descend()
-
-  for (const at of reached()) {
-    const text = read(at)
-    if (text === undefined) continue
-
-    for (const one of rowsIn(text)) {
-      const where = one.at?.split('\\').join('/')
-      if (where === undefined) continue
-      found.add(where.replace(/\.[^./]+$/, ''))
-    }
-  }
-
-  return found
-}
-
-interface Imported {
-  readonly type?: string
-  readonly source?: { readonly value?: unknown }
-  readonly specifiers?: readonly { readonly local?: { readonly name?: unknown } }[]
-}
-
-function importedFrom(name: string, ancestors: readonly unknown[]): string | undefined {
-  const program = ancestors.find((one) => (one as { readonly type?: string } | undefined)?.type === 'Program') as
-    | { readonly body?: readonly Imported[] }
-    | undefined
-  for (const one of program?.body ?? []) {
-    if (one.type !== 'ImportDeclaration' || typeof one.source?.value !== 'string') continue
-    if (!(one.specifiers ?? []).some((each) => each.local?.name === name)) continue
-    return one.source.value
-  }
-  return undefined
-}
-
-interface Typed {
-  readonly typeName?: { readonly name?: unknown }
-  readonly typeAnnotation?: Typed
-  readonly types?: readonly Typed[]
-}
-
-interface Annotated {
-  readonly type?: string
-  readonly name?: unknown
-  readonly typeAnnotation?: Typed
-}
-
-interface Held {
-  readonly type?: string
-  readonly params?: readonly Annotated[]
-  readonly body?: unknown
-}
-
-function namedIn(said: Typed | undefined): string | undefined {
-  if (said === undefined) return undefined
-  if (typeof said.typeName?.name === 'string') return said.typeName.name
-  const inner = namedIn(said.typeAnnotation)
-  if (inner !== undefined) return inner
-  for (const one of said.types ?? []) {
-    const found = namedIn(one)
-    if (found !== undefined) return found
-  }
-  return undefined
-}
-
-const typeNamed = (held: Annotated | undefined): string | undefined => namedIn(held?.typeAnnotation?.typeAnnotation)
-
-interface Stated {
-  readonly type?: string
-  readonly declarations?: readonly { readonly id?: Annotated }[]
-}
-
-function annotating(name: string, ancestors: readonly unknown[]): string | undefined {
-  for (const held of ancestors) {
-    for (const param of (held as Held).params ?? []) {
-      if (param.type !== 'Identifier' || param.name !== name) continue
-      const said = typeNamed(param)
-      if (said !== undefined) return said
-    }
-
-    const body = (held as Held).body
-    for (const one of Array.isArray(body) ? (body as readonly Stated[]) : []) {
-      if (one.type !== 'VariableDeclaration') continue
-      for (const each of one.declarations ?? []) {
-        if (each.id?.type !== 'Identifier' || each.id.name !== name) continue
-        const said = typeNamed(each.id)
-        if (said !== undefined) return said
-      }
-    }
-  }
-  return undefined
-}
-
-const settled = (from: string, source: string): string => {
-  if (!source.startsWith('.')) return source.replace(/\.[^./]+$/, '')
-  const parts = from.split('/').slice(0, -1)
-  for (const step of source.replace(/\.[^./]+$/, '').split('/')) {
-    if (step === '.' || step === '') continue
-    if (step === '..') parts.pop()
-    else parts.push(step)
-  }
-  return parts.join('/')
-}
-
-interface Called {
-  readonly callee?: { readonly type?: string; readonly name?: string; readonly property?: { readonly type?: string; readonly name?: string } }
-  readonly arguments?: readonly { readonly type?: string; readonly value?: unknown; readonly name?: string }[]
-}
-
-export const slopnator: Slopnator = {
-  on: ['CallExpression'],
-  holds: (node, at) => {
-    const call = node as Called | undefined
-    const callee = call?.callee
-    const named =
-      callee?.type === 'Identifier'
-        ? callee.name
-        : callee?.property?.type === 'Identifier'
-          ? callee.property.name
-          : undefined
-    if (named !== DISPATCH) return false
-
-    const first = call?.arguments?.[0]
-    if (first === undefined) {
-      return (
-        'dispatch is called with nothing to dispatch, so no operation is named and none can be found — the name ' +
-        'is the whole of what makes an operation reachable'
-      )
-    }
-
-    const all = declared()
-
-    if (first.type === 'Identifier' && typeof first.name === 'string') {
-      if (all.has(first.name)) return false
-      const source = importedFrom(first.name, at.ancestors())
-      if (source !== undefined && bodies().has(settled(at.filename, source))) return false
-      const named = annotating(first.name, at.ancestors())
-      const typed = named === undefined ? undefined : importedFrom(named, at.ancestors())
-      if (typed !== undefined && declaring().has(settled(at.filename, typed))) return false
-      return (
-        `dispatch is handed \`${first.name}\`, and it is not imported from a file any row declares as an operation. ` +
-        'A binding is only checkable when it is the operation — import the compiled operation and hand that over, so ' +
-        'what runs and what was declared are the same thing rather than two things that agree today'
-      )
-    }
-
-    if (first.type !== 'Literal' || typeof first.value !== 'string') {
-      return (
-        'dispatch is handed a name this file does not write down, so nothing can hold it against what is declared. ' +
-        'A name assembled at runtime reads from every check exactly like a name that was checked and found — the ' +
-        'operation is reachable and no declaration was ever consulted'
-      )
-    }
-
-    if (all.has(first.value)) return false
-
-    return (
-      `dispatch names \`${String(first.value)}\` and nothing declares an operation by that name, so this reaches for ` +
-      'something that does not exist and fails where a person is waiting rather than where it was written. ' +
-      (all.size === 0
-        ? 'Nothing declares an operation at all, so no name would have been accepted — the declaration is what has to change'
-        : `Declared: ${[...all].sort().join(', ')}`)
-    )
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          {
-            at: 'threads/_probe_operations.ts',
-            source:
-              "export const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
-          },
-          { at: 'app/_probe_unknown.tsx', source: "export const HELD = dispatch('wf_not_declared')\n" },
-        ],
-        at: 'app/_probe_unknown.tsx',
-      },
-      {
-        files: [
-          {
-            at: 'threads/_probe_operations.ts',
-            source:
-              "export const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
-          },
-          { at: 'app/_probe_built.tsx', source: "export const HELD = dispatch(`wf_${name}`)\n" },
-        ],
-        at: 'app/_probe_built.tsx',
-      },
-    ],
-    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/_probe_operations.ts',\n    },\n  ],\n}\n" },
-          {
-            at: 'threads/_probe_operations.ts',
-            source:
-              "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
-          },
-          { at: 'app/_probe_known.tsx', source: "export const HELD = dispatch('wf_send_invoice')\n" },
-        ],
-        at: 'app/_probe_known.tsx',
-      },
-      "export const HELD = translate('order.place')",
-    ],
-  },
-}