@prestack/thread 0.0.3 → 0.1.1

package/dist/operations/generators/operation.js

@@ -1,811 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { argv, exit, stderr, stdout } from 'node:process';
-import { pathToFileURL } from 'node:url';
-import { ENDS, RECEIPT, accepted, answer, asking, given as pipedIn, guidance, issue, marked, named as answerNames, needed, only, prompted, refuse, scoped, slug, spend, within, wrapped, wordsIn, } from "../../core/asking.js";
-import { generators, offers as offered, settling } from "../../core/chain.js";
-import { descend, under } from "../../core/descend.js";
-import { afterRow, holdsRow, listBounds, seedsIn, withRequires, withRow, withoutRow } from "../../core/rows.js";
-import { PREFIXES } from "../../core/thread.js";
-import { named as packageOf } from "../../core/scope.js";
-import { findTree, inTree } from "../../core/tree.js";
-import { PUBLIC_ROLE } from "../../core/actor.js";
-import { declaredWords, undeclared } from "../access.js";
-import { TAKES, WOVEN, said } from "../attach.js";
-import { ROUTE, routeAt } from "../capabilities.js";
-import { MEMBERS_LIST, OPERATIONS_FILE } from "../operations.js";
-import { SUPPLY, supplies } from "../seams.js";
-import { nodeText, scaffold } from "./seed.js";
-const TREE = findTree();
-const OPERATIONS_ID = 'operations';
-const NODES_ID = 'nodes';
-const UNDER = 'operations';
-const VERSION = 1;
-const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const here = (path) => within(TREE.at, path);
-const isType = (pass, id) => under(pass, id, NODES_ID);
-function types(pass) {
-    const found = new Set();
-    const named = new Set();
-    for (const threadings of pass.threaded.values()) {
-        for (const one of threadings)
-            if (one.row.id !== undefined)
-                named.add(one.row.id);
-    }
-    for (const one of pass.coined.keys()) {
-        if (one !== NODES_ID && !supplies(one) && !named.has(one) && under(pass, one, NODES_ID))
-            found.add(one);
-    }
-    return [...found].sort();
-}
-function capabilities(pass) {
-    const found = new Set();
-    for (const one of pass.coined.keys())
-        if (supplies(one) && under(pass, one, NODES_ID))
-            found.add(one);
-    return [...found].sort();
-}
-function existing(pass) {
-    const bodies = new Set();
-    const nodes = new Map();
-    for (const threadings of pass.threaded.values()) {
-        for (const one of threadings) {
-            if (!under(pass, one.by, OPERATIONS_ID) || isType(pass, one.by))
-                continue;
-            if (one.list === 'derives' && one.row.by === 'thread compile')
-                bodies.add(one.by);
-            if (one.list === 'seeds' && (one.row.requires ?? []).length > 0) {
-                nodes.set(one.by, [...(nodes.get(one.by) ?? []), one.row]);
-            }
-        }
-    }
-    return [...bodies].sort().map((id) => ({
-        id,
-        describes: pass.coined.get(id)?.said[0] ?? '',
-        requires: (pass.stated.get(id)?.requires ?? []).filter((one) => handed.includes(one)),
-        nodes: nodes.get(id) ?? [],
-    }));
-}
-const pass = descend();
-const known = types(pass);
-if (known.length === 0) {
-    refuse(`this app declares no node types, and a node is built from one. Attach ${packageOf('operations')} first.`);
-}
-const reachable = await (async () => {
-    const path = inTree(TREE, 'targets.ts');
-    if (!existsSync(path))
-        return [];
-    try {
-        const taken = (await import(__rewriteRelativeImportExtension(pathToFileURL(path).href)));
-        const calls = new Set((taken.CALLS ?? []).map((one) => one.id));
-        return (taken.TARGETS ?? [])
-            .filter((one) => one.takes.some((each) => calls.has(each)))
-            .map((one) => one.id)
-            .sort();
-    }
-    catch {
-        return [];
-    }
-})();
-const declared = await generators(TREE);
-const offers = offered(declared);
-const sentence = (one) => pass.coined.get(one)?.said[0] ?? pass.stated.get(one)?.describes ?? '';
-const handed = [...capabilities(pass), ...reachable];
-const already = existing(pass);
-const at = here(inTree(TREE, OPERATIONS_FILE));
-const mark = (one) => marked([
-    one.id,
-    one.describes,
-    one.requires.join(','),
-    ...one.nodes.map((row) => `${String(row.id)}:${(row.requires ?? []).join(',')}:${String(row.describes)}`),
-]);
-const listing = already.length === 0
-    ? 'no operations yet.'
-    : [
-        `${String(already.length)} operation(s):`,
-        ...already.flatMap((one) => [
-            `  [${mark(one)}] ${one.id} — ${String(one.nodes.length)} node(s) — requires ${one.requires.length === 0 ? 'nothing' : one.requires.join(', ')} — ${one.describes}`,
-            ...one.nodes.map((row, order) => `    ${String(order + 1)}. ${String(row.id)} — ${(row.requires ?? []).join(', ')} — ${String(row.describes)}`),
-        ]),
-    ].join('\n');
-const MINE = 'operation';
-const NAME = {
-    at: 'name',
-    guide: 'the word it is called by — the prefix is put on for you, and <name> on the command line skips this',
-    asks: 'name: ',
-};
-const TYPE = { at: 'type', guide: `one of ${Object.keys(PREFIXES).join(', ')} — the prefix on the id says which` };
-const DOES = { at: 'does', guide: 'what it does, in one sentence — a row without one is refused', asks: 'what does it do? ' };
-const REQUIRES = {
-    at: 'requires',
-    guide: 'what it needs, comma separated — the words under "what an operation may require" below. Blank for nothing',
-    asks: '  what does it need (comma separated, blank for nothing): ',
-};
-const TO = {
-    at: 'to',
-    guide: 'who may run it — roles, comma separated. Blank writes no grant, and then nobody may run it and its trial ' +
-        'will not reach it',
-};
-const NODES = { at: 'nodes', guide: 'how many nodes to ask for — <nodes> on the command line skips this', asks: 'how many nodes: ' };
-const INPUT = { at: 'input', guide: 'piped only — the JSON its first scenario is tried with, `{}` when left off' };
-const ANSWERS = { at: 'answers', guide: 'piped only — what the seams answer, per call' };
-const NEW = [NAME, TYPE, DOES, REQUIRES, TO, NODES, INPUT, ANSWERS];
-const NODE_NAME = { at: 'node', guide: 'its name — blank here ends it' };
-const NODE_DOES = { at: 'does', guide: 'what it does, in one sentence', asks: '  what does it do? ' };
-const NODE_TYPE = { at: 'type', guide: `one of ${known.join(', ')}`, asks: `  which type — ${known.join(', ')}: ` };
-const NODE_BODY = {
-    at: 'body',
-    guide: `the block, then a line holding only ${ENDS} — a first line of ${ENDS} leaves it unwritten, and it throws when it runs`,
-};
-const AFTER = { at: 'after', guide: 'where it goes — 0 to run first, or the node it follows. Blank for last' };
-const NODE_NEW = [NODE_NAME, NODE_DOES, NODE_TYPE, NODE_BODY];
-const ADDS = [AFTER];
-const NODE = [...NODE_NEW, ...ADDS];
-const MARK = {
-    at: 'mark',
-    guide: 'which operation — its mark from the list above. <mark> on the command line skips this',
-    asks: 'which operation — its mark from the list above: ',
-};
-const HOW = { at: 'how', guide: 'add, write or needs', asks: 'add a node, write one, or change what it needs — add, write or needs: ' };
-const WHICH = { at: 'which', guide: 'which node — 1 to N' };
-const OPENS = [MARK, HOW];
-const WRITES = [WHICH, NODE_BODY];
-const EDIT = [...OPENS, REQUIRES, ...WRITES];
-const ASKS = {
-    new: ['do', ...answerNames(NEW)],
-    edit: ['do', ...answerNames(EDIT)],
-};
-const NODE_ASKS = answerNames(NODE);
-const words = wordsIn(['new', 'edit', 'read', 'remove']);
-const verb = words[0];
-if (verb === 'read') {
-    const which = words[1];
-    const one = already.find((each) => mark(each) === which);
-    if (one === undefined) {
-        refuse(`\`${which ?? '(nothing)'}\` is not a mark this tree issued. Run \`thread create ${MINE}\` to see them — each is printed in brackets beside the operation it belongs to.`);
-    }
-    stdout.write(`${one.id} — ${one.describes}\n`);
-    stdout.write(`requires ${one.requires.length === 0 ? 'nothing' : one.requires.join(', ')}\n`);
-    for (const [order, row] of one.nodes.entries()) {
-        stdout.write(`\n  ${String(order + 1)}. ${String(row.id)} — ${(row.requires ?? []).join(', ')}\n`);
-        stdout.write(`     ${String(row.describes)}\n`);
-        if (row.at === undefined)
-            continue;
-        stdout.write(`     ${row.at}\n`);
-        let body = '';
-        try {
-            body = readFileSync(resolve(TREE.at, row.at), 'utf8');
-        }
-        catch {
-            body = '(nothing is there)\n';
-        }
-        for (const line of body.replace(/\n+$/, '').split('\n'))
-            stdout.write(`       ${line}\n`);
-    }
-    exit(0);
-}
-stdout.write(`${listing}\n`);
-function method(nonce) {
-    const asks = () => [
-        'the three things this makes, and what each takes:',
-        '',
-        `  thread create ${MINE} new <name> <nodes> ${RECEIPT} ${nonce}`,
-        '    <name>   optional — asked for if left off. Lowercased, and anything that is not a letter',
-        '             or a digit becomes _, so "Send Invoice" is send_invoice.',
-        '    <nodes>  optional — how many nodes to ask for. Left off or 0 asks until a node name is',
-        '             answered blank.',
-        '',
-        `  thread create ${MINE} edit <mark> ${RECEIPT} ${nonce}`,
-        '    <mark>   optional — asked for if left off. The six characters in brackets beside an',
-        '             operation above. It is derived from that operation\'s own rows, so it changes',
-        '             the moment the operation does.',
-        '',
-        `  thread create ${MINE} read <mark>`,
-        '    No receipt, and it writes nothing. Prints one operation, its rows, and every node file.',
-        '',
-        ...wrapped(`${RECEIPT} is spent by one run, and is refused if ${at} changed after it was issued — what ` +
-            'is listed above is what you are writing against, and handing one back says you read it.', '  '),
-    ];
-    const named = [
-        'what an operation is called:',
-        '',
-        '  You send the word. The prefix is put on for you, and there is no field holding either —',
-        '  the prefix on the id is which one a row is.',
-        '',
-        ...Object.entries(PREFIXES).map(([word, prefix]) => `    ${word.padEnd(9)} → ${prefix}<name>`),
-    ];
-    const piping = [
-        'what a program sends, rather than what a person is answering:',
-        '',
-        '  One `key: value` per line, in any order. Blank lines and lines opening with # are skipped.',
-        `  \`body:\` opens a block running to a line holding only ${ENDS}, and what is written on the`,
-        '  `body:` line itself is part of it. A new `node:` begins the next node.',
-        '',
-        '  A body is the WHOLE argument its node type is called with — an arrow function, not the',
-        '  statements inside one:  async (hands, held) => { ... }',
-        '',
-        `  \`new\` takes: ${(ASKS.new ?? []).map((one) => `\`${one}\``).join(', ')}`,
-        `  \`edit\` takes: ${(ASKS.edit ?? []).map((one) => `\`${one}\``).join(', ')}`,
-        `  each node takes: ${NODE_ASKS.map((one) => `\`${one}\``).join(', ')}`,
-    ];
-    const news = [
-        'what `new` asks, in this order:',
-        '',
-        ...guidance(NEW),
-        '',
-        '  then, for each node:',
-        '',
-        ...guidance(NODE_NEW).map((line) => `  ${line}`),
-    ];
-    const edits = [
-        'what `edit` asks:',
-        '',
-        ...guidance(OPENS),
-        '',
-        `    needs   asks \`${REQUIRES.at}\` again, as \`new\` does. It rewrites \`${REQUIRES.at}\` on that operation's`,
-        '            row and writes every one of its nodes again from it. This is how a capability is',
-        '            added to or taken off an operation.',
-        '',
-        '    write   asks these:',
-        ...guidance(WRITES).map((line) => `          ${line}`),
-        '',
-        '    add     asks the same node keys as `new`, and then, for each node:',
-        ...guidance(ADDS).map((line) => `          ${line}`),
-    ];
-    const seams = [
-        'what an operation may require, and what requiring one hands its nodes:',
-        '',
-        ...handed.flatMap((one) => [
-            `  ${one} → hands.${supplies(one) ? SUPPLY[one] : one}`,
-            ...wrapped(sentence(one), '      '),
-            ...(supplies(one)
-                ? []
-                : wrapped(`Requiring it hands a node one function per call it takes, each already knowing its verb, its path, where the target is and what opens it — so the node writes hands.${one}.<call>({ json }) and never a url, a method, a header or the name of an environment variable.`, '      ')),
-            '',
-        ]),
-        '  `requires` is written on the operation\'s own row and nowhere else — nothing else names a',
-        '  capability, and dispatch hands each node those and nothing more. `takes` is written for you',
-        `  as ['<id>_takes']: the file holding the input schema its input is parsed against, the`,
-        '  estimate it reserves against a meter, and the row its permission is checked on.',
-    ];
-    const built = [
-        'what a node may be built from, and the block each one is handed:',
-        '',
-        '  Every block ends its parameters with (hands, held) — the scaffold under each type shows',
-        '  what comes before them. `held.input` is the parsed input and `held.<node>` is what an',
-        '  earlier node returned. `hands.actor` is who asked, and `hands.<seam>` is each capability',
-        '  the operation required, above. Nothing runs a node but dispatch.',
-        '',
-        ...known.flatMap((one) => [
-            `  ${one}`,
-            ...wrapped(pass.coined.get(one)?.said[0] ?? '', '    '),
-            ...scaffold(one, '<name>').split('\n').map((line) => `      ${line}`),
-            '',
-        ]),
-    ];
-    return [asks(), named, piping, news, edits, seams, built].map((one) => one.join('\n')).join('\n\n');
-}
-const flagged = argv.indexOf(RECEIPT);
-if (flagged === -1) {
-    const nonce = issue(TREE.at, listing);
-    stdout.write(`\n${method(nonce)}\n`);
-    stdout.write(`\ncreate: receipt ${nonce} — spent on use, and stale the moment ${at} changes.\n`);
-    stdout.write(`create:   thread create ${MINE} new <name> <nodes> ${RECEIPT} ${nonce}\n`);
-    stdout.write(`create:   thread create ${MINE} edit <mark> ${RECEIPT} ${nonce}\n`);
-    stdout.write(`create:   thread create ${MINE} remove <mark> ${RECEIPT} ${nonce}\n`);
-    stdout.write(`create: reading needs no receipt — thread create ${MINE} read <mark>\n`);
-    exit(0);
-}
-spend(TREE.at, listing, argv[flagged + 1], at);
-if (verb === 'remove') {
-    const which = words[1];
-    const one = already.find((each) => mark(each) === which);
-    if (one === undefined) {
-        refuse(`\`${which ?? '(nothing)'}\` is not a mark this tree issued. Run \`thread create ${MINE}\` to see them — each is printed in brackets beside the operation it belongs to.`);
-    }
-    const held = readFileSync(inTree(TREE, OPERATIONS_FILE), 'utf8');
-    const bounds = listBounds(held, MEMBERS_LIST);
-    if (bounds === undefined)
-        refuse(`${at} states no \`${MEMBERS_LIST}\` list to remove an operation from`);
-    writeFileSync(inTree(TREE, OPERATIONS_FILE), withoutRow(held, bounds, one.id), 'utf8');
-    stdout.write(`create: removed ${one.id} from ${at}.\n`);
-    for (const gone of [`${UNDER}/${one.id}`, `${UNDER}/${one.id}.ts`, routeAt(one.id)]) {
-        const where = resolve(TREE.at, gone);
-        if (!existsSync(where))
-            continue;
-        rmSync(where, { recursive: true, force: true });
-        stdout.write(`create: deleted ${gone}\n`);
-    }
-    stdout.write(`create: the grant naming ${one.id} is \`thread grant\`'s row and is left standing — take it off with ` +
-        `\`thread grant\` so one maker is not writing another's sheet.\n`);
-    exit(0);
-}
-const held = pipedIn();
-const { own, each: piling } = scoped(held, NODE_NAME.at);
-const { piped, ask, line, shut } = asking(own);
-if (piped) {
-    const doing = verb ?? answer(own, 'do') ?? '';
-    const allowed = ASKS[doing];
-    if (allowed === undefined) {
-        refuse(`there is nothing called "${doing}" to do here — say new, edit, remove, or read, which needs no receipt`);
-    }
-    only(own, allowed, `\`${doing}\``);
-    for (const one of piling)
-        only(one, NODE_ASKS, 'a node');
-}
-const doing = verb ?? (await ask('do', 'new or edit: '));
-if (doing !== 'new' && doing !== 'edit') {
-    shut();
-    refuse(`there is nothing called "${doing}" to do here — say new, edit, remove, or read, which needs no receipt`);
-}
-async function written(from, name, scope = own) {
-    if (piped) {
-        const body = answer(scope, NODE_BODY.at);
-        return body === undefined || body === '' ? undefined : body;
-    }
-    stdout.write(`  body — what a ${from} is handed looks like this:\n`);
-    for (const line of scaffold(from, name).split('\n'))
-        stdout.write(`    ${line}\n`);
-    stdout.write(`  write yours, then a line holding only ${ENDS} — a first line of ${ENDS} leaves it unwritten, and it throws when it runs.\n`);
-    const held = [];
-    for (;;) {
-        const next = await line();
-        if (next === undefined)
-            break;
-        if (next.trim() === ENDS)
-            break;
-        held.push(next);
-    }
-    const body = held.join('\n').trim();
-    return body === '' ? undefined : body;
-}
-async function asked(order, held, scope) {
-    if (piped) {
-        if (scope === undefined)
-            return undefined;
-        const at = String(scope[0]?.at ?? 0);
-        const name = slug(scope[0]?.value ?? '');
-        if (name === '')
-            refuse(`the node opened on line ${at} is not named. ${accepted(scope)}. Nothing was written.`);
-        if (!IDENTIFIER.test(name)) {
-            refuse(`\`${name}\` on line ${at} cannot be the name of a node — it is written as a file and an export, so it starts with a letter. Nothing was written.`);
-        }
-        if (held.has(name))
-            refuse(`\`${name}\` on line ${at} is already a node of this operation. Nothing was written.`);
-        const does = needed(scope, NODE_DOES.at, `the node \`${name}\``);
-        const from = needed(scope, NODE_TYPE.at, `the node \`${name}\``);
-        if (!known.includes(from)) {
-            refuse(`\`${from}\` on line ${at} is not a node type this app declares — it declares ${known.join(', ')}. Nothing was written.`);
-        }
-        return { id: name, does, from, body: await written(from, name, scope) };
-    }
-    for (;;) {
-        const name = slug(await ask(NODE_NAME.at, `node ${String(order)} — name: `));
-        if (name === '')
-            return undefined;
-        if (!IDENTIFIER.test(name)) {
-            stdout.write(`  "${name}" cannot be the name of a node — it is written as a file and an export, so it starts with a letter.\n`);
-            continue;
-        }
-        if (held.has(name)) {
-            stdout.write(`  \`${name}\` is already a node of this operation.\n`);
-            continue;
-        }
-        const does = await ask(NODE_DOES.at, prompted(NODE_DOES));
-        if (does === '') {
-            stdout.write('  a node says what it does — that sentence is what a canvas shows and what its log is filed under.\n');
-            continue;
-        }
-        const from = await ask(NODE_TYPE.at, prompted(NODE_TYPE));
-        if (!known.includes(from)) {
-            stdout.write(`  \`${from}\` is not a node type this app declares.\n`);
-            continue;
-        }
-        return { id: name, does, from, body: await written(from, name) };
-    }
-}
-async function needs() {
-    if (piped) {
-        const answered = answer(own, REQUIRES.at) ?? '';
-        if (answered === '')
-            return [];
-        const words = [...new Set(answered.split(',').map((one) => one.trim()).filter((one) => one !== ''))];
-        const stray = words.filter((one) => !handed.includes(one));
-        if (stray.length === 0)
-            return words;
-        refuse(`this app coins no capability called ${stray.join(', ')} — a node is handed what dispatch can supply, ` +
-            `which here is ${handed.join(', ')}. Nothing was written.`);
-    }
-    stdout.write(`  what it can be handed: ${handed.join(', ')}\n`);
-    for (;;) {
-        const answered = await ask(REQUIRES.at, prompted(REQUIRES));
-        if (answered === '')
-            return [];
-        const words = [...new Set(answered.split(',').map((one) => one.trim()).filter((one) => one !== ''))];
-        const stray = words.filter((one) => !handed.includes(one));
-        if (stray.length === 0)
-            return words;
-        stdout.write(`  this app coins no capability called ${stray.join(', ')} — a node is handed what dispatch can supply.\n`);
-    }
-}
-async function placed(order, scope = own) {
-    if (order.length === 0)
-        return 0;
-    if (piped) {
-        const answered = answer(scope, AFTER.at) ?? '';
-        if (answered === '')
-            return order.length;
-        const at = Number(answered);
-        if (!Number.isInteger(at) || at < 0 || at > order.length) {
-            refuse(`there is no place ${answered} in a sequence of ${String(order.length)}. Nothing was written.`);
-        }
-        return at;
-    }
-    for (;;) {
-        const answered = await ask(AFTER.at, `  where does it go — 0 to run first, or the node it follows (1–${String(order.length)}, blank for last): `);
-        if (answered === '')
-            return order.length;
-        const at = Number(answered);
-        if (!Number.isInteger(at) || at < 0 || at > order.length) {
-            stdout.write(`  there is no place ${answered} in a sequence of ${String(order.length)}.\n`);
-            continue;
-        }
-        return at;
-    }
-}
-function after(text, where, follows, source) {
-    const held = afterRow(text, where, follows, source);
-    if (held === undefined)
-        refuse(`\`${follows}\` states no row here to place a node after`);
-    return held;
-}
-const node = (id, one) => ({
-    id: one.id,
-    at: `${UNDER}/${id}/${one.id}.ts`,
-    describes: one.does,
-    requires: [one.from],
-});
-function running(what, why) {
-    const ran = spawnSync('npx', ['thread', ...what], { cwd: TREE.at, encoding: 'utf8' });
-    stdout.write(`${`${ran.stdout ?? ''}${ran.stderr ?? ''}`.trim()}\n`);
-    if (ran.status !== 0) {
-        stderr.write(`create: ${why} The rows are written and stand; what is above is what to fix.\n`);
-        exit(1);
-    }
-}
-function recording() {
-    const was = spawnSync('npx', ['thread', 'trials', '--check'], { cwd: TREE.at, encoding: 'utf8' });
-    const said = `${was.stdout ?? ''}${was.stderr ?? ''}`.trim();
-    if (was.status !== 0 && said !== '') {
-        stdout.write(`\ncreate: what this changed about what the operation does —\n${said}\n\n`);
-    }
-    running(['trials'], 'it is declared, seeded, compiled, and the trials would not record.');
-}
-function trying(of) {
-    const typed = answer(own, INPUT.at);
-    const scripted = answer(own, ANSWERS.at);
-    const permitted = answer(own, TO.at);
-    const said = [
-        `name: s1`,
-        `input: ${typed ?? '{}'}`,
-        ...(permitted === undefined || permitted.trim() === '' ? [] : [`roles: ${permitted}`]),
-        ...(scripted === undefined ? [] : [`answers: ${scripted}`]),
-    ].join('\n');
-    const ran = piped
-        ? spawnSync('npx', ['thread', 'run', 'trial', of], { cwd: TREE.at, encoding: 'utf8', input: `${said}\n` })
-        : spawnSync('npx', ['thread', 'run', 'trial', of], { cwd: TREE.at, stdio: 'inherit' });
-    if (piped)
-        stdout.write(`${`${ran.stdout ?? ''}${ran.stderr ?? ''}`.trim()}\n`);
-    return ran.status === 0;
-}
-function granting(of, may) {
-    if (!offers.has('thread grant'))
-        return;
-    if (may.length === 0) {
-        stdout.write(`create: nobody was named as allowed to run ${of}, so no grant was written and no caller may ask for it. ` +
-            'Its trial will not reach it — a run that measured nothing has proven nothing — so `thread gate` will be red ' +
-            `until you say who may. Run \`thread grant\` when you have decided.\n`);
-        return;
-    }
-    const listed = spawnSync('npx', ['thread', 'grant'], { cwd: TREE.at, encoding: 'utf8' });
-    const ticket = /receipt ([0-9a-f]+)/.exec(`${listed.stdout ?? ''}${listed.stderr ?? ''}`)?.[1];
-    if (ticket === undefined) {
-        stdout.write(`create: \`thread grant\` issued no receipt, so the grant for ${of} was not written. Run \`thread grant\` yourself — ` +
-            'everything else about the operation stands.\n');
-        return;
-    }
-    const sheet = inTree(TREE, 'entities.ts');
-    const keeps = existsSync(sheet) && /\bid: '/.test(readFileSync(sheet, 'utf8'));
-    const answers = [
-        `Lets ${may.join(', ')} run ${of}.`,
-        ...(keeps ? [''] : []),
-        of,
-        may.join(', '),
-        '',
-        'n',
-    ].join('\n');
-    const ran = spawnSync('npx', ['thread', 'grant', 'new', `${of.replace(/^[a-z]+_/, '')}-callers`, '--receipt', ticket], {
-        cwd: TREE.at,
-        encoding: 'utf8',
-        input: `${answers}\n`,
-    });
-    stdout.write(`${`${ran.stdout ?? ''}${ran.stderr ?? ''}`.trim()}\n`);
-    if (ran.status !== 0) {
-        stderr.write(`create: ${of} is declared and seeded, and the grant was refused above. Nobody may run it until one is ` +
-            'written, so its trial will not reach it. Run `thread grant` yourself.\n');
-        exit(1);
-    }
-}
-function finish(bodies, of, fresh, may = []) {
-    const seeded = spawnSync('npx', ['thread', 'seed'], { cwd: TREE.at, encoding: 'utf8' });
-    stdout.write(`${`${seeded.stdout ?? ''}${seeded.stderr ?? ''}`.trim()}\n`);
-    if (seeded.status !== 0) {
-        stderr.write('create: it is declared and the seeder refused it. The rows are written; nothing was put on disk for them.\n');
-        exit(1);
-    }
-    for (const [where, one] of bodies) {
-        const path = resolve(TREE.at, where);
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, nodeText(where, one.name, one.takes, one.from, one.requires, one.body), 'utf8');
-        stdout.write(`create: wrote the block of ${one.name} into ${where}\n`);
-    }
-    if (fresh)
-        granting(of, may);
-    const made = spawnSync('npx', ['thread', 'compile'], { cwd: TREE.at, encoding: 'utf8' });
-    stdout.write(`${`${made.stdout ?? ''}${made.stderr ?? ''}`.trim()}\n`);
-    if (made.status !== 0) {
-        stderr.write('create: it is declared, seeded and permitted, and the compiler refused it. The rows and the grant are written ' +
-            'and stand — fix the block with `thread create operation edit`, and what the compiler refused is above.\n');
-        exit(1);
-    }
-    const MAKES = `thread create ${MINE}`;
-    for (const said of settling(TREE.at, declared, ['thread trials', MAKES]).ran)
-        stdout.write(`${said}\n`);
-    const proven = fresh ? trying(of) : (recording(), true);
-    const settled = settling(TREE.at, declared, [MAKES]);
-    for (const said of settled.ran)
-        stdout.write(`${said}\n`);
-    if (settled.unsettled.length > 0) {
-        stderr.write(`create: ${of} is declared and written, and ${settled.unsettled.join(', ')} would not settle after ` +
-            `${String(settled.rounds)} round(s). Run it yourself and read what it says — a command claiming nothing is ` +
-            'left to run while a check is still red is how a red gate becomes normal.\n');
-        exit(1);
-    }
-    if (!proven && spawnSync('npx', ['thread', 'trials', '--check'], { cwd: TREE.at, encoding: 'utf8' }).status !== 0) {
-        stderr.write(`create: ${of} is declared, seeded, compiled and everything derived from it is written — and it is not proven. ` +
-            `The trial is above. Give it what it needs, then \`thread run trial ${of}\`.\n`);
-        exit(1);
-    }
-    const compiler = compilerIn(TREE.at);
-    if (compiler === null) {
-        stdout.write('create: it is declared and seeded, and nothing here can typecheck it — this app has neither ' +
-            '`tsc6` nor `tsc` in its own `.bin`. Install a typescript, then run `thread compile`. ' +
-            'The rows are written and stand.\n');
-        exit(1);
-    }
-    const held = spawnSync(compiler, ['--noEmit'], { cwd: TREE.at, encoding: 'utf8' });
-    if (held.status === 0) {
-        stdout.write('create: it compiles. Nothing is left to run.\n');
-        exit(0);
-    }
-    stdout.write(`${`${held.stdout ?? ''}${held.stderr ?? ''}`.trim()}\n`);
-    stderr.write('create: it is declared and seeded, and the compiler refuses what is above. The rows are written and stand; what it names is what to fix.\n');
-    exit(1);
-}
-function compilerIn(at) {
-    const bin = join(at, 'node_modules', '.bin');
-    for (const name of ['tsc6', 'tsc']) {
-        if (existsSync(join(bin, name)))
-            return join(bin, name);
-    }
-    return null;
-}
-function needing(text, where, id, requires) {
-    const held = withRequires(text, where, id, requires);
-    if (held === undefined) {
-        refuse(`\`${id}\` states no row here to change, or no \`version\` to put a \`requires\` beside`);
-    }
-    return held;
-}
-const path = inTree(TREE, OPERATIONS_FILE);
-if (doing === 'edit') {
-    const which = words[1] ?? (await ask(MARK.at, prompted(MARK)));
-    const one = already.find((held) => mark(held) === which);
-    if (one === undefined) {
-        shut();
-        refuse(`\`${which}\` is not a mark on that list. Each operation's mark is printed beside it and is derived from its own rows, so naming one means having read the line it is on — and it changes the moment that operation does.`);
-    }
-    stdout.write(`${one.id} — ${one.describes}\n`);
-    for (const [order, row] of one.nodes.entries()) {
-        stdout.write(`  ${String(order + 1)}. ${String(row.id)} — ${String(row.describes)} — ${(row.requires ?? []).join(', ')}\n`);
-    }
-    stdout.write(`it requires ${one.requires.length === 0 ? 'nothing' : one.requires.join(', ')}\n`);
-    const how = await ask(HOW.at, prompted(HOW));
-    if (how === 'needs') {
-        const wanted = await needs();
-        shut();
-        const before = readFileSync(path, 'utf8');
-        const list = listBounds(before, MEMBERS_LIST);
-        if (list === undefined)
-            refuse(`${at} states no \`${MEMBERS_LIST}\` list`);
-        writeFileSync(path, needing(before, list, one.id, wanted), 'utf8');
-        stdout.write(`create: \`${one.id}\` requires ${wanted.length === 0 ? 'nothing' : wanted.join(', ')} in ${at}. Every node of it is written again from that.\n`);
-        finish(new Map(), one.id, false);
-    }
-    if (how === 'write') {
-        const numbered = Number(await ask(WHICH.at, `which node — 1 to ${String(one.nodes.length)}: `));
-        const row = one.nodes[numbered - 1];
-        if (row === undefined || row.at === undefined) {
-            shut();
-            refuse(`there is no node ${String(numbered)} in \`${one.id}\`, which has ${String(one.nodes.length)}`);
-        }
-        const from = (row.requires ?? []).find((each) => known.includes(each));
-        if (from === undefined) {
-            shut();
-            refuse(`the node \`${String(row.id)}\` requires no type this app declares, so nothing knows what shape its block takes`);
-        }
-        stdout.write(`  ${row.at} holds:\n`);
-        try {
-            for (const line of readFileSync(resolve(TREE.at, row.at), 'utf8').replace(/\n+$/, '').split('\n')) {
-                stdout.write(`    ${line}\n`);
-            }
-        }
-        catch {
-            stdout.write('    (nothing is there)\n');
-        }
-        const body = await written(from, String(row.id));
-        shut();
-        if (body === undefined)
-            refuse(`\`${String(row.id)}\` was left as it was — nothing was written`);
-        finish(new Map([[row.at, { name: String(row.id), takes: `${UNDER}/${one.id}/input.ts`, from, requires: one.requires, body }]]), one.id, false);
-    }
-    if (how !== 'add') {
-        shut();
-        refuse(`there is nothing called "${how}" to do to an operation — say add, write or needs`);
-    }
-    const order = one.nodes.map((row) => String(row.id));
-    const taken = new Set(order);
-    const added = [];
-    const bodies = new Map();
-    for (let turn = 0;; turn += 1) {
-        const scope = piped ? piling[turn] : undefined;
-        if (piped && scope === undefined)
-            break;
-        const held = await asked(order.length + 1, taken, scope);
-        if (held === undefined)
-            break;
-        const where = await placed(order, scope ?? own);
-        taken.add(held.id);
-        order.splice(where, 0, held.id);
-        const row = node(one.id, held);
-        if (held.body !== undefined) {
-            bodies.set(row.at, {
-                name: held.id,
-                takes: `${UNDER}/${one.id}/input.ts`,
-                from: held.from,
-                requires: one.requires,
-                body: held.body,
-            });
-        }
-        added.push({ row, follows: where === 0 ? `${one.id}_takes` : String(order[where - 1]) });
-    }
-    shut();
-    if (added.length === 0)
-        refuse(`\`${one.id}\` was left as it was — nothing was written`);
-    let text = readFileSync(path, 'utf8');
-    const seeding = (held) => {
-        const list = listBounds(held, MEMBERS_LIST);
-        if (list === undefined)
-            refuse(`${at} states no \`${MEMBERS_LIST}\` list`);
-        const within = seedsIn(held, list, one.id);
-        if (within === undefined)
-            refuse(`\`${one.id}\` states no \`seeds\` list to add a node to`);
-        return within;
-    };
-    for (const held of added)
-        text = after(text, seeding(text), held.follows, said(held.row, '      '));
-    writeFileSync(path, text, 'utf8');
-    stdout.write(`create: added ${String(added.length)} node(s) to ${one.id} in ${at}.\n`);
-    finish(bodies, one.id, false);
-}
-const name = slug(words[1] ?? (await ask(NAME.at, prompted(NAME))));
-if (name === '') {
-    shut();
-    refuse('an operation has to be called something');
-}
-const carried = Object.values(PREFIXES).find((one) => name.startsWith(one));
-if (carried !== undefined) {
-    shut();
-    refuse(`\`${name}\` already opens with \`${carried}\`, and the prefix is put on for you — this would ` +
-        `declare \`${carried}${name}\`. Send the word alone: \`${name.slice(carried.length)}\`.`);
-}
-const kind = await ask(TYPE.at, prompted(TYPE));
-const prefix = Object.entries(PREFIXES).find(([word]) => word === kind)?.[1];
-if (prefix === undefined) {
-    shut();
-    refuse(`there is no such type as "${kind}". An operation is a ${Object.keys(PREFIXES).join(', a ')}.`);
-}
-const id = `${prefix}${name}`;
-const describes = await ask(DOES.at, prompted(DOES));
-if (describes === '') {
-    shut();
-    refuse(`\`${id}\` was given no meaning, and a row without one is a name nobody can read`);
-}
-const requires = await needs();
-const keeping = await (async () => {
-    try {
-        const at = inTree(TREE, 'entities.ts');
-        if (!existsSync(at))
-            return [];
-        const sheet = (await import(__rewriteRelativeImportExtension(pathToFileURL(at).href)));
-        const list = sheet['ENTITIES'];
-        return Array.isArray(list) ? list : [];
-    }
-    catch {
-        return [];
-    }
-})();
-const allowed = declaredWords(keeping, 'roles', PUBLIC_ROLE);
-const answered = await ask(TO.at, `  who may run it — ${allowed.join(', ')} (blank for nobody yet): `);
-const wrong = undeclared(answered, allowed, 'roles');
-if (wrong !== undefined)
-    refuse(wrong);
-const permitted = answered
-    .split(',')
-    .map((one) => one.trim())
-    .filter((one) => one !== '');
-const counted = Number(words[2] ?? (await ask(NODES.at, prompted(NODES))));
-const nodes = [];
-const bodies = new Map();
-const taken = new Set();
-for (let order = 1; counted > 0 ? order <= counted : true; order += 1) {
-    const scope = piped ? piling[order - 1] : undefined;
-    if (piped && scope === undefined)
-        break;
-    const held = await asked(order, taken, scope);
-    if (held === undefined)
-        break;
-    taken.add(held.id);
-    const row = node(id, held);
-    if (held.body !== undefined) {
-        bodies.set(row.at, { name: held.id, takes: `${UNDER}/${id}/input.ts`, from: held.from, requires, body: held.body });
-    }
-    nodes.push(row);
-}
-shut();
-if (nodes.length === 0)
-    refuse(`\`${id}\` was given no nodes, and an operation is its nodes — nothing was written`);
-const rowFor = () => ({
-    id,
-    at,
-    describes,
-    version: VERSION,
-    ...(requires.length === 0 ? {} : { requires }),
-    takes: [`${id}_takes`],
-    seeds: [
-        { id: `${id}_takes`, at: `${UNDER}/${id}/input.ts`, describes: TAKES },
-        ...nodes,
-    ],
-    derives: [
-        { id: `${id}_body`, at: `${UNDER}/${id}.ts`, describes: WOVEN, by: 'thread compile', runs: 'thread compile --check' },
-        { id: `${id}_route`, at: routeAt(id), describes: ROUTE, by: 'thread capabilities', runs: 'thread capabilities --check' },
-    ],
-});
-const text = readFileSync(path, 'utf8');
-const where = listBounds(text, MEMBERS_LIST);
-if (where === undefined)
-    refuse(`${at} states no \`${MEMBERS_LIST}\` list to declare an operation in`);
-if (holdsRow(text, where, id))
-    refuse(`\`${id}\` is already declared in ${at}`);
-writeFileSync(path, withRow(text, where, said(rowFor(), '  ')), 'utf8');
-stdout.write(`create: declared ${id} in ${at}, with ${String(nodes.length)} node(s), requiring ${requires.length === 0 ? 'nothing' : requires.join(', ')}.\n`);
-finish(bodies, id, true, permitted);