@prestack/thread 0.1.21 → 0.1.22

package/dist/operations/generators/compile.ts

@@ -1,701 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
-import { resolve } from 'node:path'
-import { argv, stdout } from 'node:process'
-
-import ts from 'typescript'
-
-import { ROOT, descend } from '../../core/descend.ts'
-import { runChecker, type Finding } from '../../core/finding.ts'
-import { exit, invoked } from '../../core/invoked.ts'
-import { inCode, valuesIn } from '../../core/rows.ts'
-
-import { credentialsOf, holdsOf, reachOf, type Call, type Target } from '../../integrations/target.ts'
-import type { Secret } from '../../integrations/secret.ts'
-
-import { DISPATCH_AT, dispatched } from '../dispatch.ts'
-import { beside, blockIn, builtFrom, operations, problem, quoted, runtime, types } from './seed.ts'
-
-async function reaching(): Promise<Readonly<Record<string, ReturnType<typeof reached>[string]>>> {
-  const held = async <T>(file: string, list: string): Promise<readonly T[]> => {
-    const path = resolve(ROOT, `_threads/${file}`)
-    if (!existsSync(path)) return []
-    try {
-      const taken = valuesIn(readFileSync(path, 'utf8')) as Record<string, readonly T[] | undefined>
-      return taken[list] ?? []
-    } catch {
-      return []
-    }
-  }
-  const targets = await held<Target>('targets.ts', 'TARGETS')
-  const calls = await held<Call>('targets.ts', 'CALLS')
-  const secrets = await held<Secret>('secrets.ts', 'SECRETS')
-  return reached(targets, calls, secrets)
-}
-
-export function reached(
-  targets: readonly Target[],
-  calls: readonly Call[],
-  secrets: readonly Secret[],
-): Readonly<
-  Record<
-    string,
-    {
-      readonly reach: string
-      readonly address?: string
-      readonly headers: Readonly<Record<string, string>>
-  readonly sends: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]
-  readonly signs: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]
-        readonly calls: Readonly<Record<string, { readonly method: string | null; readonly path: string }>>
-    }
-  >
-> {
-  const out: Record<string, ReturnType<typeof reached>[string]> = {}
-  for (const one of targets) {
-    const mine = calls.filter((each) => each.of === one.id && one.takes.includes(each.id))
-    out[one.id] = {
-      reach: reachOf(one.id) ?? 'nothing known',
-      address: one.address,
-      headers: one.headers ?? {},
-      signs: credentialsOf(one, secrets)
-        .filter((each) => each.signs !== undefined)
-        .map((each) => ({
-          secret: each.id,
-          header: each.signs?.header ?? '',
-          prefix: each.signs?.prefix ?? '',
-        })),
-      sends: credentialsOf(one, secrets).filter((each) => each.sends !== undefined).map((each) => ({
-        secret: each.id,
-        header: each.sends?.header ?? '',
-        prefix: each.sends?.prefix ?? '',
-      })),
-
-      calls: Object.fromEntries(
-        mine.map((each) => [each.id.replace(/^cl_/, ''), { method: each.method ?? null, path: each.path }]),
-      ),
-    }
-  }
-  return out
-}
-
-const OWN = '$'
-
-const OPENED = 'opened'
-
-const ENTERED = `${OWN}at`
-
-const PLAIN = /^(?:[A-Za-z_][A-Za-z0-9_]*|'(?:[^'\\]|\\.)*')$/
-
-export function parts(text: string): readonly string[] {
-  const code = inCode(text)
-  const found: string[] = []
-  let depth = 0
-  let from = 0
-  for (let at = 0; at < text.length; at += 1) {
-    if (code[at] !== true) continue
-    const one = text[at]
-    if (one === '(' || one === '[' || one === '{') depth += 1
-    else if (one === ')' || one === ']' || one === '}') depth -= 1
-    else if (one === ',' && depth === 0) {
-      found.push(text.slice(from, at))
-      from = at + 1
-    }
-  }
-  found.push(text.slice(from))
-  return found.map((one) => one.trim()).filter((one) => one !== '')
-}
-
-const inside = (text: string, open: string, shut: string): string | undefined => {
-  const said = text.trim()
-  return said.startsWith(open) && said.endsWith(shut) ? said.slice(1, -1) : undefined
-}
-
-function keyed(text: string): { readonly key: string; readonly held: string } | undefined {
-  const code = inCode(text)
-  let depth = 0
-  for (let at = 0; at < text.length; at += 1) {
-    if (code[at] !== true) continue
-    const one = text[at]
-    if (one === '(' || one === '[' || one === '{') depth += 1
-    else if (one === ')' || one === ']' || one === '}') depth -= 1
-    else if (one === ':' && depth === 0) return { key: text.slice(0, at).trim(), held: text.slice(at + 1).trim() }
-  }
-  return undefined
-}
-
-const OPENS = 'const $ = '
-
-const ROLES = {
-  block: ['opened', 'held'],
-  over: ['held'],
-  item: ['item', 'opened', 'held'],
-  again: ['pass', 'carried', 'opened', 'held'],
-} as const satisfies Readonly<Record<string, readonly string[]>>
-
-interface Read {
-  readonly arrow: ts.ArrowFunction
-  readonly held: string | undefined
-}
-
-function arrowIn(text: string, roles: readonly string[]): Read | string {
-  const file = ts.createSourceFile('block.ts', `${OPENS}${text}`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
-  const first = file.statements[0]
-  if (first === undefined || !ts.isVariableStatement(first)) return 'is not written as a function where it is used'
-  const held = first.declarationList.declarations[0]?.initializer
-  if (held === undefined || !ts.isArrowFunction(held)) return 'is not an arrow function written where it is used'
-  if (held.parameters.length > roles.length) {
-    return `takes ${String(held.parameters.length)} things, and this kind of block is handed ${roles.join(', ')}`
-  }
-  for (const one of held.parameters) {
-    if (!ts.isIdentifier(one.name)) return 'names a parameter by taking it apart, and this needs the name itself'
-  }
-  const last = held.parameters.length === roles.length ? held.parameters[roles.length - 1] : undefined
-  const named = last !== undefined && ts.isIdentifier(last.name) ? last.name.text : undefined
-  return { arrow: held, held: named }
-}
-
-const BINDS = new Set<ts.SyntaxKind>([
-  ts.SyntaxKind.Parameter,
-  ts.SyntaxKind.VariableDeclaration,
-  ts.SyntaxKind.BindingElement,
-  ts.SyntaxKind.FunctionDeclaration,
-  ts.SyntaxKind.ClassDeclaration,
-])
-
-function bound(node: ts.Node, found: Set<string>): void {
-  if (BINDS.has(node.kind)) {
-    const said = (node as { readonly name?: ts.Node }).name
-    if (said !== undefined && ts.isIdentifier(said)) found.add(said.text)
-  }
-  if (ts.isCatchClause(node) && node.variableDeclaration !== undefined && ts.isIdentifier(node.variableDeclaration.name)) {
-    found.add(node.variableDeclaration.name.text)
-  }
-  node.forEachChild((one) => {
-    bound(one, found)
-  })
-}
-
-function answers(node: ts.Node, found: ts.ReturnStatement[]): void {
-  if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return
-  if (ts.isReturnStatement(node)) found.push(node)
-  node.forEachChild((one) => {
-    answers(one, found)
-  })
-}
-
-interface Spliced {
-  readonly form: 'expression' | 'statements' | 'call'
-
-  readonly text: string
-
-  readonly whole: string
-}
-
-function spliced(text: string, shape: Shape, roles: readonly string[]): Spliced | string {
-  const { names, mine } = shape
-  const read = arrowIn(text, roles)
-  if (typeof read === 'string') return read
-
-  const inner = new Set<string>()
-  bound(read.arrow.body, inner)
-
-  if (read.held !== undefined && inner.has(read.held)) {
-    return `declares its own \`${read.held}\` inside itself as well as taking one, and which of the two a \`${read.held}.something\` means cannot be told apart from here`
-  }
-
-  const shadows = new Set<string>(inner)
-  for (const one of read.arrow.parameters) {
-    if (ts.isIdentifier(one.name) && one.name.text !== read.held) shadows.add(one.name.text)
-  }
-
-  for (const one of shadows) {
-    if (mine.has(one)) {
-      return `uses the name \`${one}\` for something of its own, and that is also what a node of this operation is called — once both are locals one would shadow the other`
-    }
-  }
-
-  interface Edit {
-    readonly from: number
-    readonly to: number
-    readonly text: string
-  }
-
-  const edits: Edit[] = []
-  let because: string | undefined
-
-  const walk = (node: ts.Node): void => {
-    if (because !== undefined) return
-    if (read.held !== undefined && ts.isIdentifier(node) && node.text === read.held) {
-      const up: ts.Node | undefined = node.parent
-      if (up !== undefined && ts.isPropertyAccessExpression(up) && up.expression === node) {
-        const said = up.name.text
-        if (said !== 'input' && !names.has(said)) {
-
-          because =
-            `reads \`${read.held}.${said}\`, and no node before it answers to that name. ` +
-            `\`${read.held}\` holds \`input\`, which is what this operation was called with, ` +
-            (names.size === 0
-              ? 'and nothing else — this is the first node, so `input` is all there is'
-              : `and one name per node that has already answered: ${[...names].map((one) => `\`${one}\``).join(', ')}`)
-          return
-        }
-        edits.push({ from: up.getStart(), to: up.getEnd(), text: said })
-        shape.heard.add(said)
-        return
-      }
-      because = `reaches for \`${read.held}\` itself rather than one thing on it, and once every node is a local there is no such thing to hand it`
-      return
-    }
-    node.forEachChild(walk)
-  }
-  walk(read.arrow.body)
-  if (because !== undefined) return because
-
-  const held = read.arrow.parameters[roles.length - 1]
-  const before = read.arrow.parameters[roles.length - 2]
-  if (held !== undefined) {
-    edits.push({ from: before?.getEnd() ?? held.getStart(), to: held.getEnd(), text: '' })
-  }
-
-  let said = `${OPENS}${text}`
-  for (const one of [...edits].sort((a, b) => b.from - a.from)) {
-    said = `${said.slice(0, one.from)}${one.text}${said.slice(one.to)}`
-  }
-
-  const whole = said.slice(OPENS.length)
-  const again = arrowIn(whole, roles.slice(0, -1))
-  if (typeof again === 'string') return again
-  const body = again.arrow.body
-
-  if (again.arrow.parameters.length > 1) return { form: 'call', text: whole, whole }
-
-  const opens = again.arrow.parameters[0]
-  if (opens !== undefined && ts.isIdentifier(opens.name) && opens.name.text !== OPENED) {
-    return { form: 'call', text: whole, whole }
-  }
-
-  if (!ts.isBlock(body)) return { form: 'expression', text: body.getText(), whole }
-
-  const found: ts.ReturnStatement[] = []
-  answers(body, found)
-  const last = body.statements[body.statements.length - 1]
-  if (found.length === 1 && last !== undefined && found[0] === last && ts.isReturnStatement(last)) {
-    const kept = body.statements.slice(0, -1).map((one) => one.getText())
-    return { form: 'statements', text: [...kept, `${ANSWERS} = ${last.expression?.getText() ?? 'undefined'}`].join('\n'), whole }
-  }
-
-  return { form: 'call', text: whole, whole }
-}
-
-const ANSWERS = `${OWN}ANSWER`
-
-interface Made {
-  readonly runs: readonly string[]
-}
-
-interface Shape {
-  readonly all: string
-  readonly reads: string
-  readonly names: ReadonlySet<string>
-  readonly mine: ReadonlySet<string>
-  readonly heard: Set<string>
-  readonly unread: ReadonlySet<string>
-}
-
-const linesOf = (one: Spliced, name: string, unread: boolean): readonly string[] =>
-  (unread ? `${one.text.replace(`${ANSWERS} = `, 'void (')})` : one.text.replace(ANSWERS, name)).split('\n')
-
-function answered(name: string, one: Spliced, opened: string, kind: 'const' | 'let', unread: boolean): readonly string[] {
-  if (one.form === 'expression') return [unread ? `void (${one.text})` : `${kind} ${name}: unknown = ${one.text}`]
-  if (one.form === 'statements') {
-    return [...(unread ? [] : [`let ${name}: unknown`]), '{', ...linesOf(one, name, unread).map((line) => `  ${line}`), '}']
-  }
-  return [`${unread ? '' : `${kind} ${name}: unknown = `}await ${asFn(one.whole, opened)}(opened)`]
-}
-
-const asFn = (text: string, opened: string, more: string = ''): string =>
-  `((${text}) as (${more}opened: ${opened}) => Promise<unknown>)`
-
-function forked(name: string, said: readonly string[], shape: Shape): Made | string {
-  if (said.length !== 2) return `takes a chooser and the ways it chooses between, and was handed ${String(said.length)} thing(s)`
-
-  const chose = spliced(said[0] ?? '', shape, ROLES.block)
-  if (typeof chose === 'string') return `chooses with a block that ${chose}`
-
-  const held = inside(said[1] ?? '', '{', '}')
-  const ways = held === undefined ? undefined : parts(held).map((one) => keyed(one))
-  const named = ways?.every((one) => one !== undefined && PLAIN.test(one.key)) === true ? ways : undefined
-  if (named === undefined || named.length === 0) return 'names its ways in a way this cannot read — write each one as `name: block`'
-
-  const unread = shape.unread.has(name)
-  const picked = `${OWN}${name}_said`
-  const runs = [
-    ...(unread ? [] : [`let ${name}: unknown`]),
-    chose.form === 'expression'
-      ? `const ${picked}: string = await (${chose.text})`
-      : `const ${picked}: string = await ((${said[0] ?? ''}) as (opened: ${shape.reads}) => Promise<string>)(opened)`,
-    `switch (${picked}) {`,
-  ]
-
-  for (const way of named) {
-    const each = spliced(way?.held ?? '', shape, ROLES.block)
-    if (typeof each === 'string') return `has a way \`${way?.key ?? ''}\` that ${each}`
-    runs.push(`  case ${(way?.key ?? '').startsWith("'") ? (way?.key ?? '') : quoted(way?.key ?? '')}: {`)
-    if (each.form === 'expression') runs.push(unread ? `    void (${each.text})` : `    ${name} = ${each.text}`)
-    else if (each.form === 'statements') runs.push(...linesOf(each, name, unread).map((line) => `    ${line}`))
-    else runs.push(`    ${unread ? '' : `${name} = `}await ${asFn(each.whole, shape.all)}(opened)`)
-    runs.push('    break')
-    runs.push('  }')
-  }
-
-  runs.push(`  default: throw new Error(\`${name} chose \${${picked}}, which names no way forward\`)`)
-  runs.push('}')
-  return { runs }
-}
-
-const SHAPES: Readonly<Record<string, (name: string, said: readonly string[], shape: Shape) => Made | string>> = {
-  nd_read: (name, said, shape) => plainly(name, said, shape, shape.reads, false),
-  nd_action: (name, said, shape) => plainly(name, said, shape, shape.all, false),
-  nd_stop: (name, said, shape) => plainly(name, said, shape, shape.reads, true),
-
-  nd_each: (name, said, shape) => {
-    if (said.length !== 2) return `takes what to run over and the block to run, and was handed ${String(said.length)} thing(s)`
-    const over = spliced(said[0] ?? '', shape, ROLES.over)
-    const block = spliced(said[1] ?? '', shape, ROLES.item)
-    if (typeof block === 'string') return `runs a block that ${block}`
-    if (typeof over === 'string') return `runs over a block that ${over}`
-    const unread = shape.unread.has(name)
-    const item = `${OWN}${name}_item`
-    const all = `${OWN}${name}_all`
-    const each = `${OWN}${name}_each`
-    return {
-      runs: [
-        ...(unread ? [] : [`const ${all}: unknown[] = []`]),
-        `const ${each} = (${block.whole}) as (item: unknown, opened: ${shape.all}) => Promise<unknown>`,
-        `for (const ${item} of ${over.form === 'expression' ? `(${over.text})` : `((${over.whole}) as () => readonly unknown[])()`} as readonly unknown[]) {`,
-        unread ? `  await ${each}(${item}, opened)` : `  ${all}.push(await ${each}(${item}, opened))`,
-        '}',
-        ...(unread ? [] : [`const ${name}: unknown = ${all}`]),
-      ],
-    }
-  },
-
-  nd_parallel: (name, said, shape) => {
-    if (said.length !== 1) return `takes one list of blocks, and was handed ${String(said.length)} thing(s)`
-    const held = inside(said[0] ?? '', '[', ']')
-    if (held === undefined) return 'takes a list of blocks written out where it is called, and this is not one'
-    const every = parts(held)
-    if (every.length === 0) return 'was handed no blocks to run at once'
-
-    const calls: string[] = []
-    for (const [order, one] of every.entries()) {
-      const each = spliced(one, shape, ROLES.block)
-      if (typeof each === 'string') return `runs a block at position ${String(order + 1)} that ${each}`
-      calls.push(each.form === 'expression' ? `(async () => ${each.text})()` : `${asFn(each.whole, shape.all)}(opened)`)
-    }
-    return { runs: [`${shape.unread.has(name) ? '' : `const ${name}: unknown = `}await Promise.all([${calls.join(', ')}])`] }
-  },
-
-  nd_repeat: (name, said, shape) => {
-    if (said.length !== 2) return `takes a ceiling and the block to repeat, and was handed ${String(said.length)} thing(s)`
-    const block = spliced(said[1] ?? '', shape, ROLES.again)
-    if (typeof block === 'string') return `repeats a block that ${block}`
-    const ceiling = `${OWN}${name}_ceiling`
-    const again = `${OWN}${name}_again`
-    const carried = `${OWN}${name}_carried`
-    const done = `${OWN}${name}_done`
-    const pass = `${OWN}${name}_pass`
-    const answer = `${OWN}${name}_said`
-    const unread = shape.unread.has(name)
-    return {
-      runs: [
-        ...(unread ? [] : [`let ${name}: unknown`]),
-        `const ${ceiling}: number = ${said[0] ?? ''}`,
-        `const ${again} = (${block.whole}) as (pass: number, carried: unknown, opened: ${shape.all}) => Promise<{ readonly done: boolean; readonly value: unknown }>`,
-        `let ${carried}: unknown`,
-        `let ${done} = false`,
-        `for (let ${pass} = 0; ${pass} < ${ceiling}; ${pass} += 1) {`,
-        `  const ${answer} = await ${again}(${pass}, ${carried}, opened)`,
-        `  if (${answer}.done) { ${unread ? '' : `${name} = ${answer}.value; `}${done} = true; break }`,
-        `  ${carried} = ${answer}.value`,
-        '}',
-        `if (!${done}) throw new Error(\`${name} reached its ceiling of \${String(${ceiling})} passes without answering done\`)`,
-      ],
-    }
-  },
-
-  nd_branch: forked,
-}
-
-const STOPS = "Symbol.for('thread.operation.stopped')"
-
-function plainly(name: string, said: readonly string[], shape: Shape, opened: string, ends: boolean): Made | string {
-  if (said.length !== 1) return `takes one block, and was handed ${String(said.length)} thing(s)`
-  const one = spliced(said[0] ?? '', shape, ROLES.block)
-  if (typeof one === 'string') return one
-
-  const unread = shape.unread.has(name)
-  if (!ends) return { runs: answered(name, one, opened, 'const', unread) }
-
-  return {
-    runs: [
-      ...answered(name, one, opened, 'const', unread),
-      `throw Object.assign(new Error(${quoted(`${name} ended the operation`)}), { [${STOPS}]: true, value: ${name} })`,
-    ],
-  }
-}
-const saidIn = (held: ts.Expression | undefined): string | undefined =>
-  held !== undefined && ts.isStringLiteral(held) ? held.text : undefined
-
-const sourceIn = (held: ts.Expression | undefined): string | undefined => held?.getText()
-
-function compiled(
-  at: string,
-  id: string,
-  one: ReturnType<typeof operations> extends ReadonlyMap<string, infer W> ? W : never,
-  known: ReadonlySet<string>,
-  unread?: ReadonlySet<string>,
-): { readonly text?: string; readonly because?: string } {
-  const because = problem(id, one)
-  if (because !== undefined) return { because }
-
-  const takes = one.takes[0]?.at
-  if (takes === undefined) return { because: `\`${id}\` seeds what it takes and states no file for it` }
-
-  const { timeout } = one
-
-  const fields = descend().stated.get(id)?.fields
-  const entitled = saidIn(fields?.get('entitled'))
-  const rate = sourceIn(fields?.get('rate'))
-  const quota = sourceIn(fields?.get('quota'))
-  if (timeout === undefined) {
-    return {
-      because:
-        `\`${id}\` states no \`timeout\`, and an operation says how long it waits. Add \`timeout: 10_000\` to its row in ` +
-        '_threads/operations.ts, or change it with `thread edit ' + id + ' --timeout <milliseconds>`. How long a call may ' +
-        'run is part of the operation, not something the place it reaches decides',
-    }
-  }
-
-  const only = one.requires.length === 0 ? 'never' : one.requires.map((each) => quoted(each)).join(' | ')
-  const mine = new Set<string>(['input', ...one.nodes.map((row) => String(row.id))])
-
-  const runs: string[] = []
-  const names = new Set<string>()
-  const heard = new Set<string>()
-  let last: string | undefined
-
-  for (const [order, row] of one.nodes.entries()) {
-    const name = row.id
-    const from = builtFrom(row, known)
-
-    if (from === 'nd_stop' && order !== one.nodes.length - 1) {
-      const after = one.nodes.slice(order + 1).map((each) => `\`${String(each.id)}\``)
-      return {
-        because:
-          `the node \`${String(name)}\` ends \`${id}\`, and ${after.join(', ')} ${after.length === 1 ? 'is' : 'are'} declared after it. ` +
-          'Nothing runs after the node that ends an operation — move it last, or take off what follows it',
-      }
-    }
-
-    if (name === undefined) return { because: `\`${id}\` declares a node with no id of its own` }
-    if (row.at === undefined) return { because: `the node \`${name}\` names no file of its own` }
-    if (from === undefined) return { because: `the node \`${name}\` names no type this app declares` }
-
-    const path = resolve(ROOT, row.at)
-    if (!existsSync(path)) return { because: `the node \`${name}\` seeds ${row.at} and nothing is there — run \`thread seed\`` }
-    const held = blockIn(readFileSync(path, 'utf8'))
-    if (held === undefined) {
-      return { because: `the node \`${name}\` states no block this can read in ${row.at} — run \`thread seed\` and write it again` }
-    }
-
-    const shape: Shape = { all: `Opened<${only}>`, reads: `Reads<Opened<${only}>>`, names, mine, heard, unread: unread ?? new Set<string>() }
-    const made = (SHAPES[from] ?? ownType)(name, parts(held), shape)
-    if (typeof made === 'string') return { because: `the node \`${name}\` ${made}` }
-
-    runs.push(`      ${ENTERED} = ${quoted(name)}`)
-    for (const line of made.runs) runs.push(`      ${line}`)
-    names.add(name)
-    last = from === 'nd_stop' ? undefined : name
-  }
-
-  if (unread === undefined) {
-    const final = one.nodes.at(-1)?.id
-    return compiled(at, id, one, known, new Set([...mine].filter((name) => name !== final && !heard.has(name))))
-  }
-
-  const typed = ['Opened', 'Reads'].filter((word) => runs.some((line) => line.includes(`${word}<`)))
-
-  return {
-    text: [
-      "import type { z } from 'zod'",
-      '',
-      `import type { Operation } from ${quoted(runtime(at, '../operations.ts'))}`,
-      ...(typed.length === 0 ? [] : [`import type { ${typed.join(', ')} } from ${quoted(runtime(at, '../operations.ts'))}`]),
-      '',
-      `import { input, resource } from ${quoted(beside(at, takes))}`,
-      '',
-      `export const operation: Operation<z.infer<typeof input>, ${only}> = {`,
-      `  id: ${quoted(id)},`,
-      '  input,',
-      `  timeout: ${String(timeout)},`,
-      '  resource,',
-      `  requires: [${one.requires.map((each) => quoted(each)).join(', ')}],`,
-      ...(entitled === undefined ? [] : [`  entitled: ${quoted(entitled)},`]),
-      ...(rate === undefined ? [] : [`  rate: ${rate},`]),
-      ...(quota === undefined ? [] : [`  quota: ${quota},`]),
-      '',
-      '  run: async (opened, held) => {',
-      ...(unread.has('input') ? [] : ['    const input = held.input']),
-      `    let ${ENTERED} = ''`,
-      '    try {',
-      ...runs,
-      ...(last === undefined ? [] : [`      return ${last}`]),
-      '    } catch (thrown) {',
-      `      if (typeof thrown === 'object' && thrown !== null) Object.assign(thrown, { node: ${ENTERED} })`,
-      '      throw thrown',
-      '    }',
-      '  },',
-      '}',
-      '',
-    ].join('\n'),
-  }
-}
-
-const ownType = (name: string, said: readonly string[], shape: Shape): Made | string =>
-  plainly(name, said, shape, shape.all, false)
-
-interface Wanted {
-  readonly at: string
-  readonly text?: string
-  readonly because?: string
-}
-
-async function planned(): Promise<readonly Wanted[]> {
-  const pass = descend()
-  const known = types(pass)
-  const reach = await reaching()
-  const found: Wanted[] = []
-
-  const answers = Object.keys(reach).filter(
-    (one) => Object.keys(reach[one]?.calls ?? {}).length > 0 || holdsOf(one)?.takes !== 'calls',
-  )
-  const may = [...answers]
-  for (const [id, one] of operations(pass, known)) {
-    if (one.body === undefined) continue
-    const silent = one.requires.filter((each) => reach[each] !== undefined && !answers.includes(each))
-    if (silent.length > 0) {
-      found.push({
-        at: one.body,
-        because: silent
-          .map((each) => {
-            const how = reach[each]?.reach ?? 'nothing known'
-              const instead = 'declare what it answers with `thread create target call ' + each + ' <name>`'
-
-
-
-            return (
-              '`' + id + '` requires `' + each + '`, which is reached over ' + how + ' and answers no call, so there ' +
-                'is nothing for a node to be handed. ' + instead + ', ' +
-              'or take the word off that operation\'s row'
-            )
-          })
-          .join('; '),
-      })
-      continue
-    }
-    const stray = one.requires.filter((each) => !may.includes(each))
-    if (stray.length > 0) {
-      found.push({
-        at: one.body,
-        because:
-          `\`${id}\` requires ${stray.map((each) => `\`${each}\``).join(', ')}, and this app has no such capability and ` +
-          `declares no such target. What may be required is ${may.join(', ')} — declare the target with ` +
-          '`thread create target`, or take the word off that operation\'s row',
-      })
-      continue
-    }
-    found.push({ at: one.body, ...compiled(one.body, id, one, known) })
-  }
-
-  if (found.length > 0) found.push({ at: DISPATCH_AT, text: dispatched(reach) })
-  return found
-}
-
-function checked(plan: readonly Wanted[]): void {
-  if (plan.length === 0) {
-    stdout.write('compile: no operation here states a body to compile, so there is nothing to check.\n')
-    exit(0)
-  }
-
-  const findings: Finding[] = plan.flatMap((one): Finding[] => {
-    const path = resolve(ROOT, one.at)
-
-    if (one.because !== undefined) {
-      return [
-        {
-          file: one.at,
-          detail: one.because,
-          instead: 'declare it properly — this file is compiled from those rows and cannot be written without them',
-        },
-      ]
-    }
-    if (!existsSync(path)) {
-      return [{ file: one.at, detail: 'a row declares this file and nothing is there', instead: 'run `thread compile`' }]
-    }
-    if (readFileSync(path, 'utf8') === one.text) return []
-
-    if (one.at === DISPATCH_AT) {
-      return [
-        {
-          file: one.at,
-          detail: 'this is the one way every operation of this app runs, and it is no longer the bytes that write it',
-          instead:
-            'run `thread compile`. Dispatch has no author: it is the same for every app, so a change made here is a change nothing else in this framework knows about and the next compile takes it back',
-        },
-      ]
-    }
-
-    return [
-      {
-        file: one.at,
-        detail: 'this operation is compiled from its nodes, and this is no longer the bytes that compile it',
-        instead:
-          'run `thread compile`. A compiled operation has no author: to change what it does, change the rows that declare its nodes, and to change what a node does, write it in the file that node seeds',
-      },
-    ]
-  })
-
-  runChecker('compile', findings, `${String(plan.length)} file(s) compiled`)
-  exit(findings.length === 0 ? 0 : 1)
-}
-
-export async function compile(say: boolean = true): Promise<number> {
-  const plan = await planned()
-  let written = 0
-  let refused = 0
-  for (const one of plan) {
-    if (one.text === undefined) {
-      refused += 1
-      if (say) stdout.write(`compile: ${one.at} was not written — ${one.because ?? 'the rows behind it are incomplete'}\n`)
-      continue
-    }
-    const path = resolve(ROOT, one.at)
-    if (existsSync(path) && readFileSync(path, 'utf8') === one.text) continue
-    writeFileSync(path, one.text, 'utf8')
-    written += 1
-    if (say) stdout.write(`compile: wrote ${one.at}\n`)
-  }
-  if (say) {
-    stdout.write(
-      `compile: ${String(written)} of ${String(plan.length)} file(s) written, ${String(plan.length - written - refused)} already as compiled` +
-        `${refused === 0 ? '' : `, ${String(refused)} refused`}.\n`,
-    )
-  }
-  if (refused > 0) exit(1)
-  return written
-}
-
-if (invoked(import.meta.url)) {
-  if (argv.includes('--check')) checked(await planned())
-  else await compile()
-}