@prestack/thread 0.0.3 → 0.1.0

package/dist/core/cli.js

@@ -1,1761 +0,0 @@
-#!/usr/bin/env node
-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 { argv, cwd, exit, stderr, stdout } from 'node:process';
-import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { join, relative, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { CARRIES, CHAINED, RECEIPT, TYPED, VALUED, VERBS, WRITES, answer, answered, asFlag, asking, children, childrenIn, declared, given, handed, nouns, ownAnswers, reminded, rowLines, seeding, taught, withChildren } from "./asking.js";
-import { LISTS, descend } from "./descend.js";
-import { BESIDE, LOADER, refusal } from "./invoked.js";
-import { NAMED, ORGANISATION, idOf, named, ours } from "./scope.js";
-import { findTree } from "./tree.js";
-const chain = () => import("./chain.js");
-const attaching = () => import("./attach.js");
-const starting = () => import("./init.js");
-const COMMANDS = ['init', 'attach', 'detach', 'create', 'run', 'read', 'edit', 'list', 'help', 'repair'];
-const SKIPS = new Set(['node_modules', '.git', 'dist', '.next', '.thread']);
-const FINDS = '--find';
-const REPLACES = '--replace';
-const FROM = '--from';
-const REMOVES = '--remove';
-const first = (told) => {
-    const one = told.split(/(?<=\.)\s/)[0] ?? told;
-    return one.length > 88 ? `${one.slice(0, 87)}…` : one;
-};
-const opening = (told) => told.split(/(?<=\.)\s/)[0] ?? told;
-const over = (said, pad, room) => {
-    const out = [];
-    let line = '';
-    for (const word of said.split(/\s+/)) {
-        if (line === '')
-            line = word;
-        else if (`${line} ${word}`.length <= room)
-            line = `${line} ${word}`;
-        else {
-            out.push(line);
-            line = word;
-        }
-    }
-    if (line !== '')
-        out.push(line);
-    return out.map((one, at) => (at === 0 ? one : `${pad}${one}`));
-};
-const columned = (said, says, room = 22) => {
-    const pad = ' '.repeat(room + 3);
-    const [head, ...rest] = over(says, pad, 74);
-    return [`  ${said.padEnd(room)} ${head ?? ''}`, ...rest];
-};
-const commanded = (word, one) => {
-    const meaning = one.describes.trim().replace(/\.$/, '');
-    const opens = `Declares ${/^[aeiou]/.test(word) ? 'an' : 'a'} ${word}`;
-    return meaning === '' ? `${opens}.` : `${opens} — ${meaning.slice(0, 1).toLowerCase()}${meaning.slice(1)}.`;
-};
-const fielded = (word, one) => {
-    if (one === undefined || one.fields.length === 0)
-        return [];
-    const room = Math.max(...one.fields.map((each) => each.name.length));
-    const kind = (each) => each.list ? 'a list' : each.map ? 'a table' : each.boolean ? 'yes or no' : each.worded ? 'a word' : 'a value';
-    const base = ['id', 'at', 'describes', 'version'];
-    const order = (each) => {
-        const held = base.indexOf(each.name);
-        return held === -1 ? (each.required ? 100 : 200) : held;
-    };
-    return [
-        '',
-        `every ${word} row states these:`,
-        '',
-        ...[...one.fields].sort((a, b) => order(a) - order(b) || (a.name < b.name ? -1 : 1)).flatMap((each) => columned(each.name, `${each.required ? '' : 'optional, '}${kind(each)}${each.guide === '' ? '' : `. ${each.guide}`}`, room + 2)),
-    ];
-};
-const doing = (word, holds, answers, at) => {
-    const held = [
-        ...(holds === undefined
-            ? []
-            : [
-                ...columned(`${TYPED} create ${word}`, 'What it asks for, and everything already declared.', 34),
-                ...columned(`${TYPED} create ${word} read <mark>`, 'One of them in full. It writes nothing.', 34),
-            ]),
-        ...(answers?.by === undefined
-            ? []
-            : [
-                ...columned(answers.by, first(answers.describes ?? ''), 34),
-                ...(answers.runs === undefined ? [] : columned(answers.runs, 'Proves it is still what its command writes.', 34)),
-            ]),
-        ...(at === undefined ? [] : columned(`${TYPED} read ${at}`, 'Prints the file itself.', 34)),
-    ];
-    return held.length === 0 ? [] : ['', 'to do something with it:', ...held];
-};
-const OWN = [
-    {
-        said: 'read <path>',
-        describes: 'Print any file with line numbers, or list a directory. `--find <text>` searches every file in this tree. Reach for this first; `inspect <word>` reads rows instead, which is a different question.',
-    },
-    { said: 'init' },
-    { said: 'attach <package>' },
-    { said: 'detach <package>', describes: 'Give a package back, withdrawing every row it put here.' },
-    { said: 'create <noun>', describes: 'Declare a thing. Run it with no noun to see what this tree makes.' },
-    { said: 'run <noun>', describes: 'Run a thing that was declared.' },
-    {
-        said: 'edit <path|row>',
-        describes: 'Change one stretch of a file this tree declares, or one field of a row. Taking a thing out is one of the changes rather than a command of its own.',
-    },
-    {
-        said: 'list',
-        describes: 'Every command this tree answers, what each one is for, and what each thing you can declare holds.',
-    },
-    {
-        said: 'help <word>',
-        describes: 'What one word in this tree means, what declares it, what it declares, and what to run next.',
-    },
-    {
-        said: 'repair',
-        describes: 'Writes every derived file again from the rows, running each generator until a full pass changes nothing, and touches nothing you wrote. Run it when the package manifests fell out of step with the rows and pnpm refuses to start: it needs no pnpm in front of it, so `npx thread repair` in an app and `node --import tsx thread/core/cli.ts repair` in the framework repository both reach it.',
-    },
-];
-let COINED;
-const coining = () => {
-    const found = new Map();
-    try {
-        const pass = descend();
-        for (const [, threadings] of pass.threaded) {
-            for (const one of threadings) {
-                const id = one.row.id;
-                const says = one.row.describes;
-                if (typeof id === 'string' && typeof says === 'string' && says !== '' && !found.has(id))
-                    found.set(id, says);
-            }
-        }
-        for (const [id, row] of pass.stated) {
-            const says = row.describes;
-            if (typeof says === 'string' && says !== '' && !found.has(id))
-                found.set(id, says);
-        }
-    }
-    catch {
-        return found;
-    }
-    return found;
-};
-const coined = () => (COINED ??= coining());
-const verb = (one) => one.said.split(' ')[0] ?? one.said;
-const framework = () => OWN.map((one) => ({ said: one.said, describes: coined().get(verb(one)) ?? one.describes ?? '' }));
-const WORKS = [
-    'Everything this app is, it DECLARES — in `_threads/`, one row per thing. You never write those rows',
-    'by hand: `npx thread create <noun>` asks what it needs and writes one. Everything else is DERIVED',
-    'from them — the schema, the migrations, the routes, the docs — by generators that re-run themselves',
-    'whenever a row changes, so nothing has to be kept in step. `npx thread gate` refuses the tree if any',
-    'of it has drifted, and a build reads that refusal.',
-];
-const heading = (short) => [
-    ...framework().flatMap((one) => columned(one.said, short ? opening(one.describes) : one.describes)),
-    ...untold(),
-];
-const untold = () => {
-    const held = OWN.map(verb).filter((one) => !coined().has(one));
-    if (held.length === 0)
-        return [];
-    return [
-        '',
-        ...over(`${held.join(', ')} — no row coins these, so the sentence beside each is typed into this command rather ` +
-            `than read from the tree. \`${TYPED} create concept\` declares one, and this page reads it from there.`, '', 88),
-    ];
-};
-const WITHIN = '--in';
-function within(root, path) {
-    const held = resolve(root, path);
-    return held === root || held.startsWith(`${root}/`);
-}
-function every(at, root, held = []) {
-    let entries = [];
-    try {
-        entries = readdirSync(at, { withFileTypes: true });
-    }
-    catch {
-        return held;
-    }
-    for (const entry of entries) {
-        if (SKIPS.has(entry.name))
-            continue;
-        const path = join(at, entry.name);
-        if (entry.isDirectory())
-            every(path, root, held);
-        else
-            held.push(path);
-    }
-    return held;
-}
-function reading(root) {
-    const scoped = argv.indexOf(WITHIN);
-    let where = root;
-    if (scoped !== -1) {
-        const named = argv[scoped + 1];
-        if (named === undefined || named.startsWith('-')) {
-            stderr.write(`npx thread read ${WITHIN} <path> — which directory to look in. It is a place in this app, e.g. ${WITHIN} _threads.\n`);
-            return 1;
-        }
-        where = resolve(root, named);
-    }
-    const found = argv.indexOf(FINDS);
-    if (found !== -1) {
-        const looked = argv[found + 1];
-        if (looked === undefined || looked.startsWith('-')) {
-            stderr.write(`npx thread read ${FINDS} <text> — what to look for, in every file this app owns.\n`);
-            return 1;
-        }
-        let hits = 0;
-        for (const path of every(where, root)) {
-            let text = '';
-            try {
-                text = readFileSync(path, 'utf8');
-            }
-            catch {
-                continue;
-            }
-            if (!text.includes(looked))
-                continue;
-            const lines = text.split('\n');
-            for (let at = 0; at < lines.length; at += 1) {
-                if (!(lines[at] ?? '').includes(looked))
-                    continue;
-                hits += 1;
-                stdout.write(`${relative(root, path)}:${String(at + 1)}: ${(lines[at] ?? '').trim()}\n`);
-            }
-        }
-        stdout.write(`read: ${String(hits)} match(es) for ${JSON.stringify(looked)}${scoped === -1 ? ' in this whole app' : ` under ${relative(root, where) || '.'}`}` +
-            `${scoped === -1 && hits > 200 ? ` — narrow it with \`${WITHIN} <path>\`` : ''}.\n`);
-        return hits === 0 ? 1 : 0;
-    }
-    const named = argv[3] === undefined || argv[3].startsWith('-') ? (scoped === -1 ? undefined : relative(root, where)) : argv[3];
-    if (named === undefined) {
-        stderr.write([
-            `${TYPED} read <path>        print a file this app owns, with line numbers`,
-            `${TYPED} read <directory>   list what is in it, so you can name the next thing to read`,
-            `${TYPED} read ${FINDS} <text>    every line in this app that carries it, with where it is`,
-            `${TYPED} read ${FINDS} <text> ${WITHIN} <path>   the same, looking only under that directory`,
-            '',
-            'it reads and never writes, and it refuses nothing — any path on this machine, inside this app',
-            'or outside it. `npx thread inspect <word>` reads the rows instead — every row whose name or',
-            'sentence carries that word, which is a different question from every line that does.',
-            '',
-        ].join('\n'));
-        return 1;
-    }
-    const at = resolve(root, named);
-    let held;
-    try {
-        held = readdirSync(at, { withFileTypes: true });
-    }
-    catch {
-        held = undefined;
-    }
-    if (held !== undefined) {
-        const kept = held.filter((one) => !SKIPS.has(one.name)).sort((one, two) => (one.name < two.name ? -1 : 1));
-        for (const one of kept)
-            stdout.write(`${relative(root, join(at, one.name))}${one.isDirectory() ? '/' : ''}\n`);
-        stdout.write(`read: ${String(kept.length)} thing(s) in ${relative(root, at) || '.'}${held.length === kept.length ? '' : `, and ${String(held.length - kept.length)} not this app's to read`}. Name one to read it.\n`);
-        return 0;
-    }
-    let text = '';
-    try {
-        text = readFileSync(at, 'utf8');
-    }
-    catch (thrown) {
-        stderr.write(`thread: ${named} could not be read — ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-        return 1;
-    }
-    const lines = text.split('\n');
-    const width = String(lines.length).length;
-    for (let at = 0; at < lines.length; at += 1) {
-        stdout.write(`${String(at + 1).padStart(width)}  ${lines[at] ?? ''}\n`);
-    }
-    return 0;
-}
-function editable(root) {
-    const rows = [];
-    for (const [at, threadings] of descend().threaded) {
-        if (threadings.some((one) => one.list === 'derives'))
-            continue;
-        if (!existsSync(join(root, at)))
-            continue;
-        const said = threadings.map((one) => one.row.describes).find((one) => typeof one === 'string' && one !== '');
-        rows.push({ at, says: typeof said === 'string' ? said : '' });
-    }
-    return rows.sort((one, two) => (one.at < two.at ? -1 : 1));
-}
-function editing(root) {
-    const named = argv[3];
-    if (named === undefined || named.startsWith('-')) {
-        const scoped = argv.indexOf(WITHIN);
-        const under = scoped === -1 ? '' : (argv[scoped + 1] ?? '');
-        let held = [];
-        let broke = '';
-        try {
-            held = editable(root);
-        }
-        catch (thrown) {
-            broke = thrown instanceof Error ? thrown.message : String(thrown);
-        }
-        const shown = under === '' ? held : held.filter((one) => one.at === under || one.at.startsWith(`${under.replace(/\/$/, '')}/`));
-        stderr.write([
-            `${TYPED} edit <path> ${FINDS} <text> ${REPLACES} <text>`,
-            '    change one exact stretch of a file this tree declares.',
-            '',
-            'It refuses unless that text appears exactly once, because an edit that could have landed in two',
-            'places is an edit nobody can check. Widen what you look for — take in the line above or below —',
-            'until it is unique.',
-            '',
-            `  ${TYPED} read <path>          print it first, with line numbers`,
-            `  ${TYPED} read ${FINDS} <text>     find where a thing is before you change it`,
-            `  ${TYPED} edit ${WITHIN} <path>     the list below, narrowed to one directory`,
-            `  ${TYPED} edit <row> --<field> <value>   change what a ROW says, by its id or its mark`,
-            `  ${TYPED} edit <row> ${REMOVES}              take that row out of the tree`,
-            '',
-            'Naming something that is not a file here reads it as a row, and the fields you may change come',
-            'from the shape that row was declared with. So whatever `create` asked for, `edit` can change,',
-            'and taking a thing out is one of the changes rather than a command of its own.',
-            '',
-            ...VERBS,
-            '',
-            'that is why the list below is shorter than what is on disk. A file a command writes is not yours',
-            'to edit — change what it is written FROM and run that command, and the same bytes come back.',
-            '',
-            broke !== ''
-                ? `The tree could not be read, so this cannot say what you may edit — ${broke}. Run \`${TYPED} descent\`.`
-                : shown.length === 0
-                    ? under === ''
-                        ? 'This tree declares nothing you can edit yet. Everything it has is written by a command, or the ' +
-                            `descent reaches nothing on disk. \`${TYPED} descent\` says which.`
-                        : `Nothing under ${under} is yours to edit. Run \`${TYPED} edit\` with nothing after it for the whole list.`
-                    : `what this tree lets you edit${under === '' ? '' : `, under ${under}`}:`,
-            ...shown.map((one) => `  ${one.at}${one.says === '' ? '' : `\n      ${first(one.says)}`}`),
-            '',
-            'A file a command writes is not on that list. Naming one here refuses and tells you which command',
-            'writes it, so you change what it is written FROM and run that.',
-            '',
-        ].join('\n'));
-        return 1;
-    }
-    if (!within(root, named)) {
-        stderr.write(`thread: ${named} is outside this app, and this edits what the app owns.\n`);
-        return 1;
-    }
-    const found = argv.indexOf(FINDS);
-    const swapped = argv.indexOf(REPLACES);
-    const filed = argv.indexOf(`${REPLACES}-from`);
-    const wholesale = argv.indexOf(FROM);
-    const sought = argv.indexOf(`${FINDS}-from`);
-    let looked = found === -1 ? undefined : argv[found + 1];
-    if (sought !== -1) {
-        const at = argv[sought + 1];
-        if (looked !== undefined) {
-            stderr.write(`${FINDS} and ${FINDS}-from both say what to look for, and they do not have to agree. Give one. Nothing was written.\n`);
-            return 1;
-        }
-        if (at === undefined || at.startsWith('-') || !existsSync(at)) {
-            stderr.write(`${FINDS}-from names a file nothing could read, so there is nothing to look for. Nothing was written.\n`);
-            return 1;
-        }
-        looked = readFileSync(at, 'utf8').replace(/\n$/, '');
-    }
-    let put = swapped === -1 ? undefined : argv[swapped + 1];
-    if (filed !== -1) {
-        const at = argv[filed + 1];
-        if (put !== undefined) {
-            stderr.write(`${REPLACES} and ${REPLACES}-from both say what goes in, and they do not have to agree. Give one. Nothing was written.\n`);
-            return 1;
-        }
-        if (at === undefined || at.startsWith('-') || !existsSync(at)) {
-            stderr.write(`${REPLACES}-from names a file nothing could read, so there is no replacement to make. Nothing was written.\n`);
-            return 1;
-        }
-        put = readFileSync(at, 'utf8').replace(/\n$/, '');
-    }
-    const source = wholesale === -1 ? undefined : argv[wholesale + 1];
-    if (source !== undefined) {
-        stderr.write(`${FROM} replaces a whole file with what another file holds, and a file is not a receipt: nothing here ` +
-            'checked it and no descent reached it, so what it carried in was never seen. Every byte this writes ' +
-            `arrives on the command — ${FINDS} <text> ${REPLACES} <text>. Nothing was written.\n`);
-        return 1;
-    }
-    if (source === undefined && (looked === undefined || looked === '' || put === undefined)) {
-        stderr.write(`npx thread edit <path> ${FINDS} <text> ${REPLACES} <text> changes one stretch, and both are needed.\n` +
-            `npx thread edit <path> ${FROM} <file> is refused: a file is not a receipt, so every byte this writes arrives on the\n` +
-            'command. Single-quote a body that holds quotes.\n');
-        return 1;
-    }
-    const at = resolve(root, named);
-    const path = relative(root, at);
-    let threadings;
-    let outright;
-    try {
-        const pass = descend();
-        threadings = pass.threaded.get(path);
-        if (threadings === undefined) {
-            for (const one of pass.stated.values()) {
-                if (one.at === path) {
-                    outright = one;
-                    break;
-                }
-            }
-        }
-    }
-    catch (thrown) {
-        stderr.write('thread: the descent could not run, so nothing here knows what this tree declares and an edit would ' +
-            `be a guess — ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-        return 1;
-    }
-    if (threadings === undefined && outright === undefined) {
-        stderr.write(`thread: nothing declares ${path}, so it is not this tree's to change. A file the descent never reaches ` +
-            'does not exist as far as this app is concerned, and editing one would put work somewhere nothing ' +
-            'reads. Declare it first — `npx thread create` lists what this tree makes — then edit it.\n');
-        return 1;
-    }
-    const derived = (threadings ?? []).find((one) => one.list === 'derives');
-    if (derived !== undefined) {
-        const by = derived.row.by;
-        stderr.write(`thread: ${path} is derived rather than written — ${by === undefined ? 'a generator writes it' : `\`${by}\` writes it`}. ` +
-            'An edit here is reverted the next time that runs, and its `--check` fails until it is, so the change ' +
-            'you want belongs in what it is derived FROM. Change that, then run the command above.\n');
-        return 1;
-    }
-    if (source !== undefined) {
-        let body;
-        try {
-            body = readFileSync(resolve(root, source), 'utf8');
-        }
-        catch (thrown) {
-            stderr.write(`thread: ${source} could not be read, so there is nothing to put in ${path} and nothing was written — ` +
-                `${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-            return 1;
-        }
-        try {
-            writeFileSync(at, body, 'utf8');
-        }
-        catch (thrown) {
-            stderr.write(`thread: ${path} could not be written — ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-            return 1;
-        }
-        stdout.write(`thread: wrote ${path} from ${source} — ${String(body.split('\n').length)} line(s). ` +
-            `\`npx thread read ${path}\` prints what it says now.\n`);
-        stdout.write(`${reminded(undefined)}\n`);
-        return 0;
-    }
-    if (looked === undefined || put === undefined) {
-        stderr.write(`npx thread edit <path> ${FINDS} <text> ${REPLACES} <text> — both are needed.\n`);
-        return 1;
-    }
-    let text;
-    try {
-        text = readFileSync(at, 'utf8');
-    }
-    catch (thrown) {
-        stderr.write(`thread: ${path} could not be read — ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-        return 1;
-    }
-    const hits = text.split(looked).length - 1;
-    if (hits === 0) {
-        stderr.write(`thread: ${path} does not carry that text, so there is nothing to change and nothing was written. ` +
-            `\`npx thread read ${path}\` prints it, and \`npx thread read ${FINDS} <text>\` says where a thing is.\n`);
-        return 1;
-    }
-    if (hits > 1) {
-        stderr.write(`thread: that text appears ${String(hits)} times in ${path}, so this would change ${String(hits)} places ` +
-            'and you named one. Nothing was written. Widen what you look for until it appears once.\n');
-        return 1;
-    }
-    try {
-        writeFileSync(at, text.split(looked).join(put), 'utf8');
-    }
-    catch (thrown) {
-        stderr.write(`thread: ${path} could not be written — ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-        return 1;
-    }
-    stdout.write(`thread: changed ${path} — one stretch of ${String(looked.length)} character(s) became ${String(put.length)}. ` +
-        `\`npx thread read ${path}\` prints what it says now.\n`);
-    stdout.write(`${reminded(undefined)}\n`);
-    return 0;
-}
-async function surface() {
-    let rows = [];
-    let told = new Map();
-    let broke = '';
-    try {
-        const tree = findTree();
-        try {
-            rows = await (await chain()).generators(tree);
-        }
-        catch (thrown) {
-            broke = thrown instanceof Error ? thrown.message : String(thrown);
-        }
-        try {
-            told = await declared(tree);
-        }
-        catch (thrown) {
-            if (broke === '')
-                broke = thrown instanceof Error ? thrown.message : String(thrown);
-        }
-    }
-    catch (thrown) {
-        broke = thrown instanceof Error ? thrown.message : String(thrown);
-    }
-    return { rows, told, broke };
-}
-const spoken = (rows, told) => [
-    ...rows
-        .filter((one) => (one.by ?? '').startsWith('thread create '))
-        .map((one) => {
-        const word = (one.by ?? '').slice('thread create '.length);
-        const meant = told.get(word)?.describes ?? '';
-        return { said: `create ${word}`, describes: meant !== '' ? meant : (one.describes ?? '') };
-    }),
-    ...[...told]
-        .filter(([word]) => !rows.some((one) => one.by === `thread create ${word}`))
-        .map(([word, one]) => ({ said: `create ${word}`, describes: commanded(word, one) })),
-].sort((one, two) => (one.said < two.said ? -1 : 1));
-async function listing() {
-    const { rows, told, broke } = await surface();
-    const kept = (keep) => rows
-        .filter(keep)
-        .map((one) => ({ said: (one.by ?? '').slice('thread '.length), describes: one.describes ?? '' }))
-        .sort((one, two) => (one.said < two.said ? -1 : 1))
-        .flatMap((one) => columned(one.said, opening(one.describes)));
-    const makes = spoken(rows, told).flatMap((one) => {
-        const word = one.said.slice('create '.length);
-        const held = told.get(word);
-        return [
-            ...columned(one.said, opening(one.describes)),
-            ...(held === undefined
-                ? []
-                : [
-                    `${' '.repeat(25)}${held.holds === 0
-                        ? `writes into ${held.at}, where none is declared yet`
-                        : `writes into ${held.at}, where ${String(held.holds)} already ${held.holds === 1 ? 'is' : 'are'}`}`,
-                ]),
-        ];
-    });
-    const runs = kept((one) => (one.by ?? '').startsWith('thread run '));
-    const derives = kept((one) => (one.by ?? '').startsWith('thread ') && !(one.by ?? '').startsWith('thread create ') && !(one.by ?? '').startsWith('thread run '));
-    stdout.write([
-        `${TYPED} list`,
-        '',
-        ...WORKS,
-        '',
-        `every command this tree answers. These ${String(OWN.length)} are this framework's own and are here in every tree:`,
-        '',
-        ...heading(false),
-        ...(broke === ''
-            ? []
-            : [
-                '',
-                'THIS LIST IS INCOMPLETE. The tree could not be read, so everything it makes, runs and derives is',
-                `missing below — only the commands above are certain. The read failed with: ${broke}`,
-            ]),
-        ...(makes.length === 0
-            ? []
-            : ['', 'what this tree makes. Each one asks what it needs and writes the row for you:', '', ...makes]),
-        ...(runs.length === 0 ? [] : ['', 'what this tree runs:', '', ...runs]),
-        ...(derives.length === 0 ? [] : ['', 'what this tree derives from what is declared:', '', ...derives]),
-        '',
-        `${TYPED} help <word> says what any one of these words means and what to run next.`,
-        '',
-    ].join('\n'));
-    return 0;
-}
-async function repairing() {
-    let root;
-    try {
-        root = findTree().at;
-    }
-    catch {
-        stderr.write('thread: there is no tree here, so nothing declares anything and there is nothing to repair. Run `npx thread init` first.\n');
-        return 1;
-    }
-    stdout.write('thread: repairing — every generator this tree declares runs, then runs again, until a full pass changes nothing. ' +
-        'Every derived file comes back to what its rows state, and nothing you wrote is touched.\n');
-    let rows;
-    try {
-        rows = await (await chain()).generators(findTree());
-    }
-    catch (thrown) {
-        stderr.write(`thread: the tree could not be read, so nothing was repaired — ${thrown instanceof Error ? thrown.message : String(thrown)}. ` +
-            `Run \`${TYPED} issues\` and fix what it names first.\n`);
-        return 1;
-    }
-    if (rows.length === 0) {
-        stdout.write('thread: this tree declares no generator, so it derives nothing and there is nothing to repair.\n');
-        return 0;
-    }
-    const settled = (await chain()).settling(root, rows);
-    for (const said of settled.ran)
-        stdout.write(`${said}\n`);
-    if (settled.unsettled.length > 0) {
-        const writers = settled.unsettled.map((one) => one.replace(/\s*--check\s*$/, ''));
-        stderr.write(`thread: ${settled.unsettled.join(', ')} did not settle, so part of what the rows state is not on disk. ` +
-            `Run ${writers.join(', ')} alone to see what each one refuses.\n`);
-        return 1;
-    }
-    stdout.write('thread: repaired — every derived file is what its rows state. pnpm reads the package manifests before it runs anything, ' +
-        'so a workspace it refused a moment ago runs again from here.\n');
-    return 0;
-}
-async function helping(word) {
-    const { rows, told, broke } = await surface();
-    let every = [];
-    let outright;
-    let unread = '';
-    try {
-        const pass = descend();
-        for (const [at, threadings] of pass.threaded) {
-            for (const one of threadings)
-                every.push({ row: one.row, at, list: one.list, by: one.by });
-        }
-        outright = pass.stated.get(word);
-    }
-    catch (thrown) {
-        every = [];
-        outright = undefined;
-        unread = thrown instanceof Error ? thrown.message : String(thrown);
-    }
-    const own = framework().find((one) => verb(one) === word);
-    const holds = told.get(word);
-    const named = every.filter((one) => one.row.id === word);
-    const answers = rows.find((one) => one.by === `thread ${word}` || one.by === `thread create ${word}` || one.by === `thread run ${word}`);
-    if (own === undefined && holds === undefined && named.length === 0 && answers === undefined && outright === undefined) {
-        stderr.write((unread === ''
-            ? `thread: nothing in this tree is called "${word}" — no command, nothing you can declare, and no row.\n`
-            : `thread: this tree could not be read, so whether anything is called "${word}" is unknown — it was not ` +
-                `searched. Run \`${TYPED} descent\`, fix what it names, and ask again. What stopped it: ${unread}\n`) +
-            `\`${TYPED} list\` prints every command that does exist, and \`${TYPED} inspect ${word}\` searches every ` +
-            'row whose name or sentence carries it, which sometimes finds what this could not.\n' +
-            (broke === '' ? '' : `The tree could not be fully read, so this answer may be short: ${broke}\n`));
-        return 1;
-    }
-    const says = own?.describes ?? holds?.describes ?? named[0]?.row.describes ?? outright?.describes ?? answers?.describes ?? '';
-    stdout.write([
-        `${word} — ${says}`,
-        '',
-        ...(own === undefined ? [] : [`  it is one of this framework's own commands, in every tree: ${TYPED} ${own.said}`]),
-        ...named.flatMap((one) => [
-            `  it is at ${one.at}`,
-            one.list === 'declares'
-                ? `  ${one.by} declares it — a person wrote it`
-                : `  ${one.by} ${one.list} it — a command writes it`,
-        ]),
-        ...(outright === undefined || named.length > 0
-            ? []
-            : [
-                `  it is a row in ${outright.where}, in a list of its own rather than under a parent`,
-                `  ${TYPED} read ${word} prints every field it states`,
-            ]),
-        ...(holds === undefined
-            ? []
-            : [
-                holds.holds === 0
-                    ? `  nothing is declared as one yet. They are listed in ${holds.at}`
-                    : `  ${String(holds.holds)} ${holds.holds === 1 ? 'is' : 'are'} declared, listed in ${holds.at}`,
-            ]),
-        ...fielded(word, holds),
-        ...doing(word, holds, answers, named[0]?.at),
-        '',
-    ].join('\n'));
-    return 0;
-}
-function tutorial(took, core, waiting, blocked) {
-    return [
-        '',
-        '─────────────────────────────────────────────────────────────────────────',
-        '',
-        core.length === 0
-            ? 'No framework packages are installed here yet, so there was nothing to take on.'
-            : `Threaded. ${String(core.length)} package(s) on this tree: ${core.join(', ')}.${took.length === 0 ? ' All of them were already attached.' : ''}`,
-        '',
-        'HOW IT WORKS, in four sentences.',
-        '',
-        '  Everything this app is, it DECLARES — in `_threads/`, one row per thing. You never write',
-        '  those rows by hand: the `npx thread create <noun>` command asks what it needs and writes one.',
-        '  Everything else is DERIVED from them — the schema, the migrations, the routes, the docs — by',
-        '  generators that re-run themselves whenever a row changes, so nothing has to be kept in step.',
-        '  `npx thread gate` refuses the tree if any of it has drifted, and a build reads that refusal.',
-        '',
-        ...(existsSync(join(cwd(), PAGE))
-            ? [
-                `READ THIS FIRST — \`${PAGE}\`, which this command just wrote.`,
-                '',
-                '  Every node this tree declares, every command it has, and every word it coins, derived',
-                '  from the rows. It is written again whenever a row changes, so it cannot go stale, and',
-                '  it is the whole of what this app is, on one page.',
-                '',
-                `    ${TYPED} docs --show`,
-                '',
-            ]
-            : []),
-        'WHAT TO DO NEXT.',
-        '',
-        `  ${TYPED}                     every command this tree has, and what each one is for`,
-        `  ${TYPED} create              every thing you can declare, and what each one is`,
-        `  ${TYPED} create <noun>       the whole method for one of them — it asks nothing until you`,
-        '                                 hand back the receipt it prints, so reading it costs nothing',
-        `  ${TYPED} inspect <word>      every row whose name or sentence carries that word, and what`,
-        '                                 each one means — the widest read this tree has',
-        `  ${TYPED} gate                every check, run in order`,
-        '',
-        ...(waiting.length === 0
-            ? []
-            : [
-                `NOT ATTACHED, BECAUSE THEY ARE YOURS TO CHOOSE: ${waiting.join(', ')}.`,
-                '',
-                `  An app that keeps nothing needs no database, and one with no interface needs no screens.`,
-                `  Take one on when you want it — \`npx thread attach ${waiting[0]}\` — and everything`,
-                '  it declares, and everything that derives from it, arrives in the same run.',
-                '',
-            ]),
-        ...(blocked.length === 0
-            ? []
-            : [
-                `NOT TAKEN ON YET — ${String(blocked.length)} package(s) want something that is not installed:`,
-                '',
-                ...blocked.flatMap((one) => [`  ${one.name}`, `    ${one.why.replace(/\s+/g, ' ').trim()}`, '']),
-                '  Install what each names and run `npx thread init` again. Everything that could be threaded',
-                '  already has been, so nothing is lost by doing it in two goes.',
-                '',
-            ]),
-        'Nothing here is written by hand, including this app\'s own manifest and tsconfig. If you find',
-        'yourself editing a file under `_threads/` or anything a command wrote, that is the framework',
-        'missing a question — say so rather than working around it.',
-        '',
-    ].join('\n');
-}
-const META = 'The command that declares a governing node — one of the files every other row in this tree is read through, stating what it holds and what may be declared beneath it.';
-const PAGE = 'docs.md';
-const FLOOR = NAMED;
-function here(name) {
-    try {
-        createRequire(join(cwd(), 'package.json')).resolve(`${name}/attach`);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function offered() {
-    try {
-        return await (await chain()).generators(findTree());
-    }
-    catch (thrown) {
-        stderr.write(`thread: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-        exit(1);
-    }
-}
-const MINE = 'thread';
-const UNDER = 'generators';
-const MAKING = 'makers';
-function own(name, under = UNDER) {
-    let found;
-    const look = (at) => {
-        for (const entry of readdirSync(at, { withFileTypes: true })) {
-            if (!entry.isDirectory() || entry.name === 'node_modules')
-                continue;
-            const made = join(at, entry.name, under, `${name}.ts`);
-            try {
-                readFileSync(made);
-                found = made;
-                return;
-            }
-            catch {
-                look(join(at, entry.name));
-            }
-            if (found !== undefined)
-                return;
-        }
-    };
-    try {
-        look(join(cwd(), MINE));
-    }
-    catch {
-        return undefined;
-    }
-    return found;
-}
-async function derived(name) {
-    if (argv.includes('--own')) {
-        const mine = own(name);
-        if (mine === undefined) {
-            stderr.write(`thread: \`--own\` means this repository's own generator, and there is none named ` +
-                `"${name}" under any package here. Drop the flag to use an app's tree instead.\n`);
-            return 1;
-        }
-        argv[1] = mine;
-        argv.splice(2, 1);
-        try {
-            await import(__rewriteRelativeImportExtension(pathToFileURL(mine).href));
-            return 0;
-        }
-        catch (thrown) {
-            stderr.write(`thread: \`npx thread ${name} --own\` is at ${mine}, and running it threw: ` +
-                `${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-            return 1;
-        }
-    }
-    const all = await offered();
-    const offers = all.filter((one) => (one.by ?? '').startsWith('thread '));
-    const held = offers.find((one) => one.by === `thread ${name}`);
-    if (held?.at === undefined) {
-        let makes = [];
-        try {
-            makes = [...(await declared(findTree())).keys()].map((one) => `create ${one}`);
-        }
-        catch {
-            makes = [];
-        }
-        const named = [
-            ...new Set([...COMMANDS, 'create meta', ...makes, ...offers.map((one) => (one.by ?? '').slice('thread '.length))]),
-        ].sort();
-        stderr.write(`thread: no command named "${name}". There is: ${named.join(', ')}\n`);
-        return 1;
-    }
-    const at = resolve(findTree().at, held.at);
-    argv[1] = at;
-    argv.splice(2, 1);
-    try {
-        await import(__rewriteRelativeImportExtension(pathToFileURL(at).href));
-        return 0;
-    }
-    catch (thrown) {
-        stderr.write(`thread: \`npx thread ${name}\` is declared by \`${held.id ?? ''}\` at ${held.at}, and running it threw: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-        return 1;
-    }
-}
-function stated(root) {
-    const under = join(root, '_threads');
-    try {
-        return readdirSync(under)
-            .filter((one) => one.endsWith('.ts') || one.endsWith('.json'))
-            .sort()
-            .map((one) => {
-            try {
-                return `${one}:${readFileSync(join(under, one), 'utf8')}`;
-            }
-            catch {
-                return `${one}:`;
-            }
-        })
-            .join('\n');
-    }
-    catch {
-        return '';
-    }
-}
-function declaring(was) {
-    const dir = findTree().dir;
-    for (const one of readdirSync(dir)) {
-        if (!one.endsWith('.ts'))
-            continue;
-        const now = readFileSync(join(dir, one), 'utf8');
-        const older = was.get(one) ?? '';
-        if (now === older)
-            continue;
-        const before = ids(older);
-        const after = ids(now);
-        const count = (list, id) => list.filter((each) => each === id).length;
-        const fresh = [...new Set(after)].filter((each) => count(after, each) > count(before, each));
-        if (fresh.length === 0)
-            continue;
-        const outer = fresh
-            .flatMap((each) => rowsFor(now, each).map((source) => ({ id: each, source })))
-            .filter((each) => !older.includes(each.source))
-            .sort((a, b) => b.source.length - a.source.length);
-        const held = outer[0];
-        if (held === undefined)
-            return undefined;
-        return { sheet: one, now, id: held.id, source: held.source };
-    }
-    return undefined;
-}
-const states = (row, field) => new RegExp(`\\n\\s*${field}:`).test(row);
-let heard = new Map();
-function adopted(was) {
-    if (argv.includes('edit'))
-        return;
-    let kids;
-    let own;
-    try {
-        kids = new Map([...childrenIn(given()), ...heard]);
-        own = ownAnswers(given());
-    }
-    catch {
-        return;
-    }
-    const plain = CARRIES.map((one) => ({ field: one, said: (answer(own, one) ?? '').trim() })).filter((one) => one.said !== '');
-    if (kids.size === 0 && plain.length === 0)
-        return;
-    const held = declaring(was);
-    if (held === undefined)
-        return;
-    const owed = new Map([...kids].filter(([list]) => !states(held.source, list)));
-    const rest = plain
-        .filter((each) => !states(held.source, each.field))
-        .map((each) => ({ field: each.field, said: each.said, list: each.field !== 'by' && each.field !== 'runs' }));
-    if (owed.size === 0 && rest.length === 0)
-        return;
-    const pad = (/\n(\s*)id:/.exec(held.source) ?? [, '    '])[1] ?? '    ';
-    const grown = withChildren(held.source, rowLines(pad, rest, owed));
-    writeFileSync(join(findTree().dir, held.sheet), held.now.replace(held.source, grown), 'utf8');
-    const named = [...rest.map((each) => each.field), ...[...owed.keys()]];
-    stdout.write(`thread: wrote ${named.join(', ')} onto ${held.id} in ${findTree().name}/${held.sheet}.\n`);
-    for (const said of seeding(owed, findTree().at))
-        stdout.write(`thread: ${said}\n`);
-}
-function rowsFor(text, id) {
-    const mark = `id: '${id}'`;
-    const found = [];
-    for (let at = text.indexOf(mark); at !== -1; at = text.indexOf(mark, at + 1)) {
-        const row = rowAt(text, at);
-        if (row !== undefined)
-            found.push(row);
-    }
-    return found;
-}
-function rowAt(text, at) {
-    let open = text.lastIndexOf('{', at);
-    if (open === -1)
-        return undefined;
-    let depth = 0;
-    for (let each = open; each < text.length; each += 1) {
-        if (text[each] === '{')
-            depth += 1;
-        if (text[each] === '}') {
-            depth -= 1;
-            if (depth === 0) {
-                const end = text[each + 1] === ',' ? each + 2 : each + 1;
-                while (open > 0 && text[open - 1] !== '\n')
-                    open -= 1;
-                return text.slice(open, end);
-            }
-        }
-    }
-    return undefined;
-}
-const ids = (text) => [...text.matchAll(/\n\s*id: '([^']+)'/g)].map((one) => one[1]);
-const SELF = fileURLToPath(import.meta.url);
-const FOLDER = 'src/generators';
-const kebab = (one) => one.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-const shared = (one, two) => {
-    const here = one.split('/');
-    const there = two.split('/');
-    let same = 0;
-    while (same < here.length && same < there.length && here[same] === there[same])
-        same += 1;
-    return same;
-};
-function folderFor(rows, at) {
-    const held = new Map();
-    for (const row of rows) {
-        const path = (row.at ?? '').trim();
-        if (path === '' || !path.includes('/'))
-            continue;
-        const folder = path.slice(0, path.lastIndexOf('/'));
-        held.set(folder, (held.get(folder) ?? 0) + 1);
-    }
-    if (held.size === 0)
-        return FOLDER;
-    const ranked = [...held].sort((one, two) => {
-        const near = shared(two[0], at) - shared(one[0], at);
-        return near === 0 ? two[1] - one[1] : near;
-    });
-    return ranked[0]?.[0] ?? FOLDER;
-}
-const BY_IN = /\bby:\s*'([^']+)'/g;
-const AT_IN = /\bat:\s*'([^']+)'/;
-function sheetsNow() {
-    const found = new Map();
-    try {
-        for (const one of readdirSync(findTree().dir)) {
-            if (!one.endsWith('.ts'))
-                continue;
-            found.set(one, readFileSync(join(findTree().dir, one), 'utf8'));
-        }
-    }
-    catch {
-        return found;
-    }
-    return found;
-}
-function writtenOwed(was, commands) {
-    const out = [];
-    const seen = new Set();
-    for (const [name, text] of sheetsNow()) {
-        const before = was.get(name);
-        if (before === text)
-            continue;
-        const had = new Set((before ?? '').split('\n'));
-        for (const line of text.split('\n')) {
-            if (had.has(line))
-                continue;
-            for (const found of line.matchAll(BY_IN)) {
-                const by = (found[1] ?? '').trim();
-                if (by === '' || commands.has(by) || seen.has(by))
-                    continue;
-                seen.add(by);
-                out.push({ at: AT_IN.exec(line)?.[1] ?? '', by, runs: '' });
-            }
-        }
-    }
-    return out;
-}
-function generated(rows, was) {
-    if (argv.includes(CHAINED))
-        return [];
-    let kids;
-    try {
-        kids = new Map([...childrenIn(given()), ...heard]);
-    }
-    catch {
-        kids = new Map();
-    }
-    const commands = new Set(rows.map((one) => (one.by ?? '').trim()).filter((one) => one !== ''));
-    const asked = [...(kids.get('derives') ?? []), ...(kids.get('seeds') ?? [])]
-        .filter((one) => {
-        const by = (one.by ?? '').trim();
-        return by !== '' && !commands.has(by);
-    })
-        .map((one) => ({ at: one.at, by: (one.by ?? '').trim(), runs: (one.runs ?? '').trim(), writes: one.writes }));
-    const named = new Set(asked.map((one) => one.by));
-    const found = writtenOwed(was, commands).filter((one) => !named.has(one.by));
-    let top = '';
-    try {
-        top = (answer(given(), WRITES) ?? '').trim();
-    }
-    catch {
-        top = '';
-    }
-    const owed = [
-        ...asked,
-        ...found.map((one) => (found.length === 1 && top !== '' && one.writes === undefined ? { ...one, writes: top } : one)),
-    ];
-    if (owed.length === 0)
-        return [];
-    const short = [];
-    for (const one of owed) {
-        const by = one.by;
-        const name = kebab(by.replace(/^thread\s+/, ''));
-        const file = one.at === '' ? 'the file that row names' : one.at;
-        if (name === '') {
-            short.push(`the row states \`by: '${by}'\`, which is no command name, so nothing can be declared to write ${file}.`);
-            continue;
-        }
-        if (one.writes === undefined || one.writes.trim() === '') {
-            short.push(`${file} is written by \`${by}\`, and this tree has no such command. A generator is what would answer it, and ` +
-                `none was declared, because the body one would be made from was not given — ${asFlag(WRITES)} is that body. ` +
-                'Give it on this command and the generator is declared in the same run.');
-            continue;
-        }
-        stdout.write(`thread: nothing writes ${file} yet — \`${by}\` is a command this tree does not have. Declaring it.\n`);
-        const asked = spawnSync(process.execPath, [...LOADER, SELF, 'create', 'generator', CHAINED], {
-            encoding: 'utf8',
-            input: '',
-        });
-        const receipt = /--receipt ([0-9a-f]+)/.exec(asked.stdout ?? '')?.[1];
-        if (receipt === undefined) {
-            short.push(`\`${TYPED} create generator\` issued no receipt, so the generator behind \`${by}\` was not declared and ` +
-                `nothing writes ${file}.`);
-            continue;
-        }
-        const runs = one.runs;
-        const ran = spawnSync(process.execPath, [
-            ...LOADER, SELF, 'create', 'generator', 'new', CHAINED,
-            '--name', name,
-            '--describes',
-            `Writes ${file}. It runs as \`${by}\`${runs === '' ? '' : `, and \`${runs}\` says whether what it wrote still matches`}.`,
-            '--folder', folderFor(rows, one.at),
-            '--by', by,
-            ...(runs === '' ? [] : ['--runs', runs]),
-            ...(one.writes === undefined || one.writes === '' ? [] : ['--body', one.writes]),
-            '--receipt', receipt,
-        ], { stdio: 'inherit' });
-        if (ran.status !== 0) {
-            short.push(`the generator behind \`${by}\` was refused, so nothing writes ${file}.`);
-        }
-    }
-    return short;
-}
-async function deleting(root, targets) {
-    const named = targets.map((one) => relative(root, resolve(root, one)).split('\\').join('/'));
-    const missing = named.filter((one) => !existsSync(resolve(root, one)));
-    if (missing.length > 0) {
-        stderr.write(`thread: there is nothing at ${missing.join(', ')}, so nothing was taken out.\n`);
-        return 1;
-    }
-    let declared;
-    let derived;
-    try {
-        const pass = await descend();
-        declared = new Set([...pass.threaded.keys(), ...pass.mentioned.keys()]);
-        derived = new Set([...pass.threaded].filter(([, threadings]) => threadings.every((one) => one.list === 'derives')).map(([at]) => at));
-    }
-    catch {
-        stderr.write('thread: the descent will not run, so whether a row names these has no answer — and deleting a file a row ' +
-            'still names leaves that row pointing at nothing. Run `npx thread issues` and fix what it reports first.\n');
-        return 1;
-    }
-    const under = (one) => {
-        if (!statSync(resolve(root, one)).isDirectory())
-            return [one];
-        return readdirSync(resolve(root, one), { withFileTypes: true }).flatMap((each) => under(`${one}/${each.name}`));
-    };
-    const asked = named.filter((one) => !statSync(resolve(root, one)).isDirectory() && declared.has(one) && !derived.has(one));
-    if (asked.length > 0) {
-        stderr.write(`thread: a row names ${asked.join(', ')}, and a file taken out from under its row leaves the row naming ` +
-            'nothing. Take the row out first — `npx thread edit <row> --remove` prints the row it found and what to ' +
-            'run — then take out the file. Nothing was taken out.\n');
-        return 1;
-    }
-    const every = named.flatMap(under);
-    const kept = every.filter((one) => declared.has(one) && !derived.has(one));
-    const going = every.filter((one) => !declared.has(one) || derived.has(one));
-    const back = going.filter((one) => derived.has(one));
-    if (going.length === 0) {
-        stdout.write('thread: every file there is declared, so there is nothing to take out.\n');
-        return 0;
-    }
-    for (const one of going)
-        rmSync(resolve(root, one));
-    stdout.write(`thread: took out ${String(going.length)} file(s)` +
-        (back.length === 0
-            ? ' nothing declared'
-            : ` — ${String(back.length)} of them derived, so the command each one's row names in \`by\` writes it again`) +
-        `${kept.length > 0 ? `, and left the ${String(kept.length)} that rows name` : ''}.\n`);
-    stdout.write(`${reminded(undefined)}\n`);
-    return 0;
-}
-const either = (all) => all.length < 2 ? (all[0] ?? '') : `${all.slice(0, -1).join(', ')} or ${all[all.length - 1] ?? ''}`;
-async function wizard(was) {
-    const held = declaring(was);
-    if (held === undefined)
-        return 0;
-    let coming;
-    try {
-        coming = new Set(childrenIn(given()).keys());
-    }
-    catch {
-        coming = new Set();
-    }
-    const owed = LISTS.filter((list) => !coming.has(list) && !states(held.source, list));
-    if (owed.length === 0)
-        return 0;
-    if (answered()) {
-        if (owed.length < LISTS.length)
-            return 0;
-        stdout.write(`thread: ${held.id} names no file it ${either(owed)}. Name them on the create itself: ` +
-            '`--declares <id> --at <path> --describes <sentence>` for a file a person wrote, `--derives` with ' +
-            '`--by <command>` and `--runs <command>` for one a command writes, and `--seeds` with `--body <text>` ' +
-            'or `--from <path>` for one a command shapes and you fill in.\n');
-        return 0;
-    }
-    stdout.write(`\nthread: every file ${held.id} owns is named here, or nothing in this tree knows it exists.\n` +
-        '  If it exists, declare it. If a command can write it, derive it. Otherwise seed it and write it now.\n');
-    const { ask, line, shut } = asking([]);
-    const found = new Map();
-    try {
-        for (const list of owed) {
-            const kids = await children(list, [], ask, line);
-            if (kids.length > 0)
-                found.set(list, kids);
-        }
-    }
-    catch (thrown) {
-        shut();
-        heard = found;
-        if (refusal(thrown) === undefined)
-            throw thrown;
-        return 1;
-    }
-    shut();
-    heard = found;
-    return 0;
-}
-async function dispatching(verb, makes, brings) {
-    if (argv.includes('--own')) {
-        const noun = argv[3];
-        if (noun === undefined || noun.startsWith('-')) {
-            stderr.write(`npx thread ${verb} <noun> --own\n`);
-            return 1;
-        }
-        const mine = own(noun, MAKING);
-        if (mine === undefined) {
-            stderr.write(`thread: \`--own\` means this repository's own maker, and there is none named "${noun}" ` +
-                'under any package here. Drop the flag to use an app\'s tree instead.\n');
-            return 1;
-        }
-        argv[1] = mine;
-        argv.splice(2, 2);
-        try {
-            await import(__rewriteRelativeImportExtension(pathToFileURL(mine).href));
-            return 0;
-        }
-        catch (thrown) {
-            stderr.write(`thread: \`npx thread ${verb} ${noun} --own\` is at ${mine}, and running it threw: ` +
-                `${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-            return 1;
-        }
-    }
-    let offering;
-    let rows = [];
-    try {
-        rows = await offered();
-        offering = nouns(rows, verb);
-    }
-    catch {
-        offering = new Map();
-    }
-    let told = new Map();
-    if (verb === 'create') {
-        const mine = fileURLToPath(new URL(BESIDE('./generators/meta'), import.meta.url));
-        const already = offering.get('meta');
-        if (already !== undefined && already !== mine) {
-            stderr.write(`thread: a row states \`by: 'thread create meta'\` — ${already} — and this package answers meta ` +
-                'itself, so which one answers a meta is whichever was read first. One noun, one file.\n');
-            return 1;
-        }
-        const grown = new Map(offering).set('meta', mine);
-        try {
-            told = await declared(findTree());
-            for (const noun of told.keys())
-                if (!grown.has(noun))
-                    grown.set(noun, mine);
-        }
-        catch {
-            told = new Map();
-        }
-        offering = grown;
-    }
-    const said = [...offering.keys()].sort();
-    const noun = argv[3];
-    const how = `thread: a package brings a noun into being by declaring a row that states \`by: 'thread ${verb} <noun>'\` and the file that answers it.\n`;
-    if (noun === undefined || noun.startsWith('-')) {
-        const sentence = (word) => {
-            const meant = told.get(word)?.describes ?? '';
-            if (meant !== '')
-                return first(meant);
-            return first(rows.find((one) => one.by === `thread ${verb} ${word}`)?.describes ??
-                (word === 'meta' ? META : ((() => {
-                    const held = told.get(word);
-                    return held === undefined ? '' : commanded(word, held);
-                })())));
-        };
-        stderr.write(said.length === 0
-            ? `npx thread ${verb} <noun>\n\nthis tree ${brings} — ${how.replace('thread: ', '')}`
-            : [
-                `npx thread ${verb} <noun>`,
-                '',
-                `this tree ${makes}:`,
-                '',
-                ...said.map((word) => `  ${word.padEnd(12)} ${sentence(word)}`),
-                '',
-                'where a noun comes from, and what answers it:',
-                '',
-                '  a list of rows names it. `export const PACKAGES: readonly Package[]` in a sheet makes',
-                `  \`npx thread ${verb} package\` exist from that moment, asking for whatever a \`Package\` states.`,
-                '  Nothing is added to a list of commands anywhere — this reads what your tree declares.',
-                '',
-                `  a row may answer it instead. A row stating \`by: 'thread ${verb} package'\` names the file that`,
-                '  runs, and that file wins over this one. The list still names the noun; the row names what',
-                '  answers. Declare no such row and this command answers it itself, which is usually enough.',
-                '',
-                '  a field nobody has a sentence for stops it. Every question is read from the word the field',
-                '  is named after, so a field whose word this tree coins is asked for with no work at all, and',
-                '  one it does not coin refuses by name rather than writing a row with a hole in it.',
-                `  \`npx thread ${verb} concept\` is how a word gets coined.`,
-                '',
-                `run \`npx thread ${verb} <noun>\` with nothing after it and it lists what is already declared,`,
-                'with a mark beside each, and states every question it will ask before it asks one.',
-                `\`npx thread read <row>\` prints every field one of them states, and writes nothing — read`,
-                'what is there before adding to it.',
-                '',
-                'every noun asks for a `describes`, and it is the one answer nothing can derive. It is what',
-                'the glossary shows, what a form labels the thing with, and what the next person reads.',
-                '',
-                '  say what the thing IS to somebody who has not seen it, not what it is called.',
-                '  one sentence, ending in a full stop. Say why it exists if that is not obvious.',
-                '',
-                '  no:   "the user email"        — the id again, with spaces',
-                '  no:   "email field"           — its type, which the type already says',
-                '  yes:  "Where we reach somebody who has asked us to. Not how we identify them: an',
-                '         address changes hands, and a row it addressed would follow it."',
-                '',
-            ].join('\n'));
-        return 1;
-    }
-    const held = offering.get(noun);
-    if (held === undefined) {
-        stderr.write(`thread: there is nothing this can ${verb} called "${noun}". This tree ${makes}: ${said.length === 0 ? '(nothing)' : said.join(', ')}.\n${how}`);
-        return 1;
-    }
-    const at = resolve(findTree().at, held);
-    argv[1] = at;
-    argv.splice(2, 2);
-    process.env.THREAD_NOUN = noun;
-    const addressed = told.get(noun)?.fields.some((one) => one.name === 'at') ?? false;
-    process.env[VALUED] = addressed ? '' : '1';
-    if (verb === 'create') {
-        const opens = argv[2];
-        const bare = !argv.includes(RECEIPT) && (opens === undefined || opens.startsWith('-'));
-        if (bare) {
-            const commands = new Set(rows.map((one) => (one.by ?? '').trim()));
-            stdout.write(`${taught(noun, told, commands).join('\n')}\n`);
-        }
-    }
-    const sheets = () => {
-        const found = new Map();
-        try {
-            for (const one of readdirSync(findTree().dir)) {
-                if (!one.endsWith('.ts'))
-                    continue;
-                found.set(one, readFileSync(join(findTree().dir, one), 'utf8'));
-            }
-        }
-        catch {
-            return found;
-        }
-        return found;
-    };
-    const was = sheets();
-    const before = stated(findTree().at);
-    let answering = rows;
-    const { settling } = await chain();
-    process.on('exit', () => {
-        if (stated(findTree().at) === before)
-            return;
-        adopted(was);
-        const missing = generated(answering, was);
-        if (missing.length > 0) {
-            for (const said of missing)
-                stderr.write(`thread: ${said}\n`);
-            stderr.write('thread: the row is written and what it names is not. A `derives` or `seeds` row states the command that ' +
-                'writes its file, and this tree has no such command — so the row names a file nothing will ever write. ' +
-                `Declare the generator with \`${TYPED} create generator\`, giving it ${asFlag(WRITES)}, or take the row ` +
-                `out with \`${TYPED} edit <row> --remove\`.\n`);
-            process.exitCode = 1;
-        }
-        let settled;
-        stdout.write('thread: the row is written. Settling the tree now — every generator this tree declares runs, then every check runs, ' +
-            'and nothing prints until a round ends, so a large tree sits quiet here for minutes.\n');
-        try {
-            settled = settling(findTree().at, rows);
-        }
-        catch (thrown) {
-            stdout.write('thread: the row is written, and what it derives was not built — reading what this tree offers threw: ' +
-                `${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-            return;
-        }
-        for (const said of settled.ran)
-            stdout.write(`${said}\n`);
-        if (settled.unsettled.length === 0)
-            return;
-        const writers = settled.unsettled.map((one) => one.replace(/\s*--check\s*$/, ''));
-        stdout.write(`thread: ${settled.unsettled.join(', ')} did not settle, so what this row derives is not built yet. ` +
-            `Run: ${writers.join(', ')}\n`);
-    });
-    if (verb === 'create')
-        process.on('exit', () => stdout.write(`${reminded(noun)}\n`));
-    const piped = handed();
-    const ran = spawnSync(process.execPath, [...LOADER, at, ...argv.slice(2)], {
-        ...(piped === undefined ? {} : { input: piped }),
-        stdio: [piped === undefined ? 'inherit' : 'pipe', 'inherit', 'inherit'],
-        env: { ...process.env, THREAD_NOUN: noun },
-    });
-    if (ran.error !== undefined) {
-        stderr.write(`thread: \`${noun}\` is declared as answered by ${held}, and running it threw: ${ran.error.message}\n`);
-        return 1;
-    }
-    if (ran.status !== 0)
-        return ran.status ?? 1;
-    try {
-        answering = await (await chain()).generators(findTree());
-    }
-    catch {
-        answering = rows;
-    }
-    if (verb !== 'create')
-        return 0;
-    return await wizard(was);
-}
-const HELP = new Set(['--help', '-h', 'help']);
-async function attachable(verb) {
-    let installed = [];
-    try {
-        installed = readdirSync(join(cwd(), 'node_modules', ORGANISATION))
-            .map((one) => idOf(`${ORGANISATION}/${one}`))
-            .filter((one) => one !== undefined);
-    }
-    catch {
-        installed = [];
-    }
-    let already = [];
-    try {
-        already = readdirSync(findTree().dir).map((one) => one.replace(/\.ts$/, ''));
-    }
-    catch {
-        already = [];
-    }
-    const version = (one) => {
-        try {
-            const said = createRequire(join(cwd(), 'package.json')).resolve(`${named(one)}/package.json`);
-            const held = JSON.parse(readFileSync(said, 'utf8'));
-            return held.version ?? '';
-        }
-        catch {
-            return '';
-        }
-    };
-    const here = installed.filter((one) => one !== 'core').sort();
-    const offered = verb === 'attach' ? here : here.filter((one) => already.includes(one));
-    if (offered.length === 0) {
-        return verb === 'attach'
-            ? [
-                `nothing to attach — no \`${named('*')}\` package is installed here beyond the CLI itself.`,
-                `Install one with \`npm install -D ${named('<name>')}\` — this framework is scaffolding, so it goes in \`devDependencies\` and a host installs none of it — then run this again to see it listed.`,
-            ]
-            : [
-                'nothing to detach — this tree has taken on no package yet.',
-                'What is installed is not what is attached: run `npx thread attach` to see what may be taken on.',
-            ];
-    }
-    const stale = new Map();
-    for (const one of offered) {
-        if (!already.includes(one))
-            continue;
-        const held = await (await attaching()).behind(cwd(), named(one));
-        if (held.length > 0)
-            stale.set(one, held.length);
-    }
-    const numbers = new Set([...installed, 'core'].map(version).filter((one) => one !== ''));
-    const width = Math.max(...offered.map((one) => named(one).length)) + 2;
-    return [
-        `${NAMED} ${version('core')} — the CLI you are running.`,
-        '',
-        `installed here, and what may be ${verb === 'attach' ? 'attached' : 'detached'}:`,
-        '',
-        ...offered.map((one) => `  ${named(one)}${' '.repeat(width - named(one).length)}${version(one)}` +
-            `${already.includes(one) ? `   (attached${stale.has(one) ? `, ${String(stale.get(one) ?? 0)} row(s) behind` : ''})` : ''}`),
-        '',
-        ...(stale.size === 0
-            ? []
-            : [
-                `${[...stale.keys()].map(named).join(', ')} ${stale.size === 1 ? 'ships rows' : 'ship rows'} this tree has not taken on.`,
-                'Installing a package does not write its rows — the rows live in your sheets and `npx thread attach` is what puts',
-                `them there. Run \`npx thread attach ${[...stale.keys()].map(named).join('` and `npx thread attach `')}\` to take them.`,
-                '',
-            ]),
-        ...(numbers.size <= 1
-            ? []
-            : [
-                `these are not all the same release — ${[...numbers].sort().join(', ')} are installed together. They ship as one,`,
-                `so \`npm install ${named('<name>')}@latest\` for whichever is behind, and attach again to take its rows.`,
-                '',
-            ]),
-        ...(verb === 'attach'
-            ? []
-            : [
-                'what detaching does, before you do it:',
-                '',
-                '  every row that package put here is withdrawn — its sheet in `_threads/`, the rows it',
-                '  appended to other sheets, the nouns it brought, and the scripts it wrote into the manifest.',
-                '  What YOU declared with `npx thread create` into a sheet that package owns goes with the sheet,',
-                '  because the sheet is the package\'s. A package another one is attached to refuses to go',
-                '  until that one has, and it names which.',
-                '',
-                '  Nothing is installed or uninstalled by this. It is about what this tree declares, and the',
-                '  package stays on disk ready to attach again.',
-                '',
-            ]),
-        ...(verb === 'attach'
-            ? [
-                'a package brings its own commands, its own checks and its own sheet. Attach one and',
-                '`npx thread create` grows the nouns it declares — run it after to see what changed.',
-            ]
-            : [
-                'run `npx thread issues` first. A package is rarely the thing that is wrong, and detaching one',
-                'to reach a single bad row withdraws everything else it brought along with it.',
-            ]),
-    ];
-}
-async function run(name) {
-    const asked = argv[3];
-    if (name === 'help' && asked !== undefined && !asked.startsWith('-'))
-        return await helping(asked);
-    if (name !== undefined && HELP.has(name)) {
-        await run(undefined);
-        return 0;
-    }
-    if (name === undefined) {
-        let rows = [];
-        let unread = '';
-        try {
-            const tree = findTree();
-            try {
-                rows = await (await chain()).generators(tree);
-            }
-            catch (thrown) {
-                unread = thrown instanceof Error ? thrown.message : String(thrown);
-            }
-        }
-        catch {
-            rows = [];
-        }
-        const under = (kept, keep, also = []) => [
-            ...kept.filter(keep).map((one) => ({ said: (one.by ?? '').slice('thread '.length), describes: one.describes ?? '' })),
-            ...also,
-        ]
-            .sort((one, two) => (one.said < two.said ? -1 : 1))
-            .flatMap((one) => columned(one.said, opening(one.describes)));
-        let told = new Map();
-        try {
-            told = await declared(findTree());
-        }
-        catch {
-            told = new Map();
-        }
-        const makes = under(rows, () => false, spoken(rows, told));
-        const runs = under(rows, (one) => (one.by ?? '').startsWith('thread run '));
-        const derives = under(rows, (one) => (one.by ?? '').startsWith('thread ') && !(one.by ?? '').startsWith('thread create ') && !(one.by ?? '').startsWith('thread run '));
-        stderr.write([
-            `${TYPED} <command>`,
-            '',
-            ...WORKS,
-            '',
-            `a tree is made, attached to, and then declared into. These ${String(OWN.length)} are this framework's own:`,
-            '',
-            ...heading(true),
-            ...(unread === ''
-                ? []
-                : [
-                    '',
-                    'THIS PAGE IS INCOMPLETE. This tree is here but could not be read, so everything it makes,',
-                    'runs and derives is missing below — only the six commands above are certain.',
-                    `  the read failed with: ${unread}`,
-                    'Until that is fixed, a command missing from this page means nothing at all.',
-                ]),
-            ...(makes.length === 0
-                ? []
-                : ['', 'what this tree makes — each states what it wants and writes the row for you:', '', ...makes]),
-            ...(runs.length === 0 ? [] : ['', 'what this tree runs:', '', ...runs]),
-            ...(derives.length === 0
-                ? []
-                : [
-                    '',
-                    'what this tree derives from what is declared. You rarely run these yourself — a command',
-                    'that writes a row runs whatever its change made stale, and `npx thread gate` runs every check:',
-                    '',
-                    ...derives,
-                ]),
-            '',
-            ...(await attachable('attach')),
-            '',
-            `read before you write: \`${TYPED} read <id>\` prints exactly what one row declares and the file it`,
-            'names, needs no receipt, and writes nothing. Run any noun above with no arguments to see what',
-            'already exists, each with its sentence, and the whole method it asks. That is a ROW — `read <path>`',
-            'at the top of this page is a FILE, and when one of the two comes back empty the other usually does not.',
-            '',
-            'this page is what THIS tree answers, not everything thread can do. A command that is not listed',
-            'may be one no attached package brings rather than one that does not exist, so `attach` first and',
-            'look again. And try it anyway: an unknown command prints every command that does exist.',
-            '',
-        ].join('\n'));
-        return 1;
-    }
-    if (name === 'create') {
-        return await dispatching('create', 'makes', 'makes nothing yet');
-    }
-    async function settled() {
-        let rows;
-        try {
-            rows = await (await chain()).generators(findTree());
-        }
-        catch (thrown) {
-            stderr.write(`thread: the packages are attached and their rows are written; what they derive was not built, because ` +
-                `reading what this tree offers threw: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-            return;
-        }
-        if (rows.length === 0)
-            return;
-        const settled = (await chain()).settling(findTree().at, rows);
-        for (const said of settled.ran)
-            stdout.write(`${said}\n`);
-        if (settled.unsettled.length > 0) {
-            const writers = settled.unsettled.map((one) => one.replace(/\s*--check\s*$/, ''));
-            stdout.write(`thread: ${settled.unsettled.join(', ')} did not settle. The rows are written; what they derive is not built ` +
-                'yet, which is usually because this attach named dependencies your app does not have yet — a generator ' +
-                `cannot read a tree whose compiler cannot resolve it. Install them, then run: ${writers.join(', ')}\n`);
-        }
-    }
-    if (name === 'run') {
-        return await dispatching('run', 'runs', 'runs nothing yet');
-    }
-    if (name === 'read') {
-        let root = cwd();
-        let threaded = true;
-        try {
-            root = findTree().at;
-        }
-        catch {
-            root = cwd();
-            threaded = false;
-        }
-        const target = argv[3];
-        if (threaded && target !== undefined && !target.startsWith('-') && !existsSync(resolve(root, target))) {
-            argv.splice(2, 1, 'create', 'meta', 'read');
-            return await dispatching('create', 'makes', 'makes nothing yet');
-        }
-        return reading(root);
-    }
-    if (name === 'list')
-        return await listing();
-    if (name === 'repair')
-        return await repairing();
-    if (name === 'edit') {
-        let root = cwd();
-        try {
-            root = findTree().at;
-        }
-        catch {
-            stderr.write('thread: there is no tree here, so nothing declares anything and there is no body this owns. ' +
-                'Run `npx thread init` first.\n');
-            return 1;
-        }
-        const target = argv[3];
-        if (target !== undefined && !target.startsWith('-') && !existsSync(resolve(root, target)) && !argv.includes(FROM)) {
-            const dropping = argv.indexOf(REMOVES);
-            if (dropping !== -1)
-                argv.splice(dropping, 1);
-            argv.splice(2, 1, 'create', 'meta', dropping === -1 ? 'edit' : 'remove');
-            return await dispatching('create', 'makes', 'makes nothing yet');
-        }
-        if (target !== undefined && !target.startsWith('-') && argv.includes(REMOVES)) {
-            return await deleting(root, argv.slice(3).filter((one) => !one.startsWith('-')));
-        }
-        return editing(root);
-    }
-    if (name === 'attach' || name === 'detach') {
-        const which = argv[3];
-        if (which === undefined) {
-            stderr.write([`npx thread ${name} <package>`, '', ...(await attachable(name)), ''].join('\n'));
-            return 1;
-        }
-        try {
-            const { attach, behind, detach } = await attaching();
-            const brought = name === 'attach' ? await behind(cwd(), which) : [];
-            const touched = name === 'attach' ? await attach(cwd(), which) : await detach(cwd(), which);
-            if (touched.length === 0) {
-                stdout.write(`thread: no changes — every row ${which} ships is already in this tree, at the version installed.\n`);
-            }
-            if (touched.length > 0 && name === 'attach') {
-                const gained = [...new Set(brought.map((one) => one.says).filter((one) => one !== undefined))].sort();
-                if (gained.length > 0) {
-                    stdout.write(`thread: this tree now answers ${gained.map((one) => `\`${one}\``).join(', ')} — run any of them bare to see what it does.\n`);
-                }
-            }
-            for (const one of touched)
-                stdout.write(`thread: ${name === 'attach' ? 'wrote' : 'changed'} ${one}\n`);
-            if (touched.length > 0)
-                await settled();
-            return 0;
-        }
-        catch (thrown) {
-            stderr.write(`thread: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-            return 1;
-        }
-    }
-    if (name !== 'init')
-        return await derived(name);
-    try {
-        const { attach, attaches } = await attaching();
-        for (const one of (await starting()).init(cwd()))
-            stdout.write(`thread: wrote ${one}\n`);
-        const installed = () => {
-            try {
-                const manifest = JSON.parse(readFileSync(join(cwd(), 'package.json'), 'utf8'));
-                return [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})]
-                    .filter(ours)
-                    .sort();
-            }
-            catch {
-                return [];
-            }
-        };
-        const core = [];
-        const skipped = [];
-        for (const one of installed()) {
-            if (!(await attaches(cwd(), one)))
-                continue;
-            if (one === NAMED)
-                core.push(one);
-            else
-                skipped.push(one);
-        }
-        const took = [];
-        const blocked = [];
-        for (const one of core) {
-            try {
-                const touched = await attach(cwd(), one);
-                if (touched.length > 0)
-                    took.push(one);
-                for (const each of touched)
-                    stdout.write(`thread: wrote ${each}\n`);
-            }
-            catch (thrown) {
-                blocked.push({ name: one, why: thrown instanceof Error ? thrown.message : String(thrown) });
-            }
-        }
-        for (const one of blocked)
-            core.splice(core.indexOf(one.name), 1);
-        if (!here(FLOOR)) {
-            stdout.write(`thread: ${FLOOR} is not installed, so this tree has no gate and nothing yet refuses anything. ` +
-                `Install it with \`npm install ${FLOOR}\`, then run \`npx thread attach ${FLOOR}\`.\n`);
-        }
-        const onDisk = (one) => existsSync(join(cwd(), 'node_modules', one, 'package.json'));
-        const declared = (() => {
-            try {
-                const manifest = JSON.parse(readFileSync(join(cwd(), 'package.json'), 'utf8'));
-                return [
-                    ...new Set([...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})]),
-                ].sort();
-            }
-            catch {
-                return [];
-            }
-        })();
-        const absent = declared.filter((one) => !onDisk(one));
-        if (absent.length > 0) {
-            stdout.write(`thread: ${absent.join(', ')} ${absent.length === 1 ? 'is' : 'are'} declared here and not on disk. ` +
-                'Installing, because an attach that adds a package to this manifest and then leaves it unfetched has ' +
-                'handed you a tree its own generators cannot read.\n');
-            const ran = spawnSync('npm', ['install'], { cwd: cwd(), stdio: 'inherit' });
-            const still = absent.filter((one) => !onDisk(one));
-            if (ran.status !== 0 || still.length > 0) {
-                stderr.write(`thread: \`npm install\` did not put ${still.length === 0 ? 'them' : still.join(', ')} on disk` +
-                    `${ran.status === null || ran.status === 0 ? '' : ` — it exited ${String(ran.status)}`}. The rows are ` +
-                    'written and what they derive is not built, and it stays that way until the install succeeds. ' +
-                    'Nothing after this ran.\n');
-                return 1;
-            }
-            stdout.write(`thread: installed ${absent.join(', ')}.\n`);
-        }
-        await settled();
-        stdout.write(tutorial(took, core, skipped, blocked));
-        return 0;
-    }
-    catch (thrown) {
-        stderr.write(`thread: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
-        return 1;
-    }
-}
-exit(await run(argv[2]));