@prestack/thread 0.0.1 → 0.0.2

package/dist/operations/generators/compile.js

@@ -448,10 +448,29 @@ async function planned() {
     const known = types(pass);
     const reach = await reaching();
     const found = [];
-    const may = [...SUPPLIES, ...Object.keys(reach)];
+    const answers = Object.keys(reach).filter((one) => Object.keys(reach[one]?.calls ?? {}).length > 0);
+    const may = [...SUPPLIES, ...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 = how === 'module' || how === 'cli'
+                        ? 'run it with `thread run ' + each.replace(/^[a-z]+_/, '') + '`'
+                        : 'reach the rows it keeps with `sm_store`';
+                    return ('`' + id + '` requires `' + each + '`, which is reached over ' + how + ' and answers no call, so there ' +
+                        'is nothing for a node to be handed. ' + instead + ', give it a call with `thread create target call`, ' +
+                        '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({

package/dist/operations/generators/compile.ts

@@ -0,0 +1,643 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, 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 } from '../../core/rows.ts'
+
+import { addressOf, credentialsOf, reachOf, type Call, type Target } from '../../integrations/target.ts'
+import type { Secret } from '../../integrations/secret.ts'
+
+import { DISPATCH_AT, dispatched } from '../dispatch.ts'
+import { SUPPLIES } from '../seams.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 = (await import(new URL(`file://${path}`).href)) 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)
+}
+
+function reached(
+  targets: readonly Target[],
+  calls: readonly Call[],
+  secrets: readonly Secret[],
+): Readonly<
+  Record<
+    string,
+    {
+      readonly reach: string
+      readonly address: string | null
+      readonly sends: readonly { readonly secret: string; readonly header: string; readonly prefix: string }[]
+      readonly calls: Readonly<Record<string, { readonly method: string; 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: addressOf(one, secrets)?.id ?? null,
+      sends: credentialsOf(one, secrets).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, path: each.path }]),
+      ),
+    }
+  }
+  return out
+}
+
+const OWN = '$'
+
+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: ['hands', 'held'],
+  over: ['held'],
+  item: ['item', 'hands', 'held'],
+  again: ['pass', 'carried', 'hands', '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,
+  names: ReadonlySet<string>,
+  mine: ReadonlySet<string>,
+  roles: readonly string[],
+): Spliced | string {
+  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 })
+        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 }
+
+  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>
+}
+
+function answered(name: string, one: Spliced, hands: string, kind: 'const' | 'let'): readonly string[] {
+  if (one.form === 'expression') return [`${kind} ${name}: unknown = ${one.text}`]
+  if (one.form === 'statements') {
+    return [`let ${name}: unknown`, '{', ...one.text.split('\n').map((line) => `  ${line.replace(ANSWERS, name)}`), '}']
+  }
+  return [`${kind} ${name}: unknown = await ${asFn(one.whole, hands)}(hands)`]
+}
+
+const asFn = (text: string, hands: string, more: string = ''): string =>
+  `((${text}) as (${more}hands: ${hands}) => 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.names, shape.mine, 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 picked = `${OWN}${name}_said`
+  const runs = [
+    `let ${name}: unknown`,
+    chose.form === 'expression'
+      ? `const ${picked}: string = await (${chose.text})`
+      : `const ${picked}: string = await ((${said[0] ?? ''}) as (hands: ${shape.reads}) => Promise<string>)(hands)`,
+    `switch (${picked}) {`,
+  ]
+
+  for (const way of named) {
+    const each = spliced(way?.held ?? '', shape.names, shape.mine, 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(`    ${name} = ${each.text}`)
+    else if (each.form === 'statements') runs.push(...each.text.split('\n').map((line) => `    ${line.replace(ANSWERS, name)}`))
+    else runs.push(`    ${name} = await ${asFn(each.whole, shape.all)}(hands)`)
+    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.names, shape.mine, ROLES.over)
+    const block = spliced(said[1] ?? '', shape.names, shape.mine, ROLES.item)
+    if (typeof block === 'string') return `runs a block that ${block}`
+    if (typeof over === 'string') return `runs over a block that ${over}`
+    const item = `${OWN}${name}_item`
+    const all = `${OWN}${name}_all`
+    const each = `${OWN}${name}_each`
+    return {
+      runs: [
+        `const ${all}: unknown[] = []`,
+        `const ${each} = (${block.whole}) as (item: unknown, hands: ${shape.all}) => Promise<unknown>`,
+        `for (const ${item} of ${over.form === 'expression' ? `(${over.text})` : `((${over.whole}) as () => readonly unknown[])()`} as readonly unknown[]) {`,
+        `  ${all}.push(await ${each}(${item}, hands))`,
+        '}',
+        `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.names, shape.mine, 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)}(hands)`)
+    }
+    return { runs: [`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.names, shape.mine, 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`
+    return {
+      runs: [
+        `let ${name}: unknown`,
+        `const ${ceiling}: number = ${said[0] ?? ''}`,
+        `const ${again} = (${block.whole}) as (pass: number, carried: unknown, hands: ${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}, hands)`,
+        `  if (${answer}.done) { ${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, hands: 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.names, shape.mine, ROLES.block)
+  if (typeof one === 'string') return one
+
+  if (!ends) return { runs: answered(name, one, hands, 'const') }
+
+  return {
+    runs: [
+      ...answered(name, one, hands, 'const'),
+      `throw Object.assign(new Error(${quoted(`${name} ended the operation`)}), { [${STOPS}]: true, value: ${name} })`,
+    ],
+  }
+}
+
+function compiled(
+  at: string,
+  id: string,
+  one: ReturnType<typeof operations> extends ReadonlyMap<string, infer W> ? W : never,
+  known: 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 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>()
+  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: `Handed<${only}>`, reads: `Reads<Handed<${only}>>`, names, mine }
+    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
+  }
+
+  return {
+    text: [
+      "import type { z } from 'zod'",
+      '',
+      `import type { Operation } from ${quoted(runtime(at, '../operations.ts'))}`,
+      `import type { Handed, Reads } from ${quoted(runtime(at, '../seams.ts'))}`,
+      '',
+      `import { estimate, input, resource } from ${quoted(beside(at, takes))}`,
+      '',
+      `export const operation: Operation<z.infer<typeof input>, ${only}> = {`,
+      `  id: ${quoted(id)},`,
+      '  input,',
+      '  estimate,',
+      '  resource,',
+      `  requires: [${one.requires.map((each) => quoted(each)).join(', ')}],`,
+      '',
+      '  run: async (hands, held) => {',
+      '    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)
+  const may = [...SUPPLIES, ...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 =
+              how === 'module' || how === 'cli'
+                ? 'run it with `thread run ' + each.replace(/^[a-z]+_/, '') + '`'
+                : 'reach the rows it keeps with `sm_store`'
+            return (
+              '`' + id + '` requires `' + each + '`, which is reached over ' + how + ' and answers no call, so there ' +
+              'is nothing for a node to be handed. ' + instead + ', give it a call with `thread create target call`, ' +
+              '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 {
+  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
+    mkdirSync(dirname(path), { recursive: true })
+    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()
+}