@prestack/thread-ui 0.0.1

package/dist/ui/generators/routes.js

@@ -0,0 +1,597 @@
+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 { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { argv, stderr, stdout } from 'node:process';
+import { pathToFileURL } from 'node:url';
+import ts from 'typescript';
+import { exit, invoked } from "@prestack/thread/core/invoked";
+import { named as packageOf } from "@prestack/thread/core/scope";
+import { findTree, inTree } from "@prestack/thread/core/tree";
+import { nameOf as compositionOf } from "../compositions.js";
+import { PRESENTATIONS } from "../door.js";
+import { PAGE, entryAmong, nameOf, pageAt, presentedIn, routeFor } from "../screens.js";
+import { keyProps } from "./i18n.js";
+const LAYOUT = `app/layout.${'tsx'}`;
+const WORDING = `app/_generated/wording.${'ts'}`;
+const DECLARED = `src/_generated/seams.${'ts'}`;
+const CLIENT = `app/_generated/dispatching.${'ts'}`;
+const DOOR = `app/_generated/door.${'tsx'}`;
+const MAP = `app/_generated/map.${'ts'}`;
+const PROVIDER = `${packageOf('ui')}/provider`;
+const GRAMMAR = `${packageOf('ui')}/islands/map`;
+const MOVES = 'navigateTo';
+function door(knowing, wording, dispatching, moving, presenting) {
+    const opening = presenting.length > 0;
+    const props = `asking={ASKING}${knowing ? ' actor={actor}' : ''}${dispatching ? ' dispatch={dispatchTo}' : ''}` +
+        `${moving ? ' navigateTo={navigateTo}' : ''}${wording ? ' locale={SOURCE} wording={WORDING}' : ''}`;
+    return [
+        "'use client'",
+        '',
+        '/* GENERATED by thread — do not edit. It is derived from what this app declares. */',
+        '',
+        ...(moving
+            ? [`import { useCallback, ${opening ? 'useState, ' : ''}type ReactNode } from 'react'`, "import { useRouter } from 'next/navigation'"]
+            : ["import type { ReactNode } from 'react'"]),
+        '',
+        `import { ThreadUi } from '${PROVIDER}'`,
+        '',
+        "import { ASKING } from './declared.ts'",
+        ...(dispatching ? ["import { dispatchTo } from './dispatching.ts'"] : []),
+        ...(moving ? ["import { MAP } from './map.ts'"] : []),
+        ...(wording ? ["import { SOURCE, WORDING } from './wording.ts'"] : []),
+        ...(opening ? ['', ...presenting.map((one) => `import { ${one.name} } from '${reaching(DOOR, one.at)}'`)] : []),
+        '',
+        'export function Door({',
+        ...(knowing
+            ? ['  actor,']
+            : []),
+        '  children,',
+        '}: {',
+        ...(knowing
+            ? ['  readonly actor?: { readonly id: string | null; readonly roles: readonly string[]; readonly entitlements: readonly string[] }']
+            : []),
+        '  readonly children: ReactNode',
+        '}) {',
+        ...(moving
+            ? [
+                '  const router = useRouter()',
+                ...(opening ? ['  const [presented, setPresented] = useState<string | undefined>(undefined)'] : []),
+                '  const navigateTo = useCallback(',
+                '    (screen: string): void => {',
+                ...(opening
+                    ? [
+                        '      const found = MAP.screens.find((one) => one.id === screen)',
+                        '      if (found === undefined) {',
+                        '        throw new Error(',
+                        '          `thread: \\`${screen}\\` is not a screen this app has, so there is nothing to go to. ` +',
+                        "            `The screens are ${MAP.screens.map((one) => one.id).join(', ')}.`,",
+                        '        )',
+                        '      }',
+                        '      if (found.path === undefined) {',
+                        '        setPresented(screen)',
+                        '        return',
+                        '      }',
+                        '      setPresented(undefined)',
+                        '      router.push(found.path)',
+                    ]
+                    : [
+                        '      const path = MAP.screens.find((one) => one.id === screen)?.path',
+                        '      if (path === undefined) {',
+                        '        throw new Error(',
+                        '          `thread: \\`${screen}\\` is not a screen this app has, so there is nothing to go to. ` +',
+                        "            `The screens are ${MAP.screens.map((one) => one.id).join(', ')}.`,",
+                        '        )',
+                        '      }',
+                        '      router.push(path)',
+                    ]),
+                '    },',
+                '    [router],',
+                '  )',
+                ...(opening ? ['  const dismiss = useCallback((): void => setPresented(undefined), [])'] : []),
+            ]
+            : []),
+        ...(opening
+            ? [
+                '  return (',
+                `    <ThreadUi ${props}>`,
+                '      {children}',
+                ...presenting.map((one) => `      <${one.name} open={presented === '${one.name}'} onDismiss={dismiss} />`),
+                '    </ThreadUi>',
+                '  )',
+            ]
+            : [`  return <ThreadUi ${props}>{children}</ThreadUi>`]),
+        '}',
+        '',
+    ].join('\n');
+}
+const TYPED = /screen\(\s*'[^']*'\s*,\s*\{[^}]*route:\s*'([^']*)'/;
+export function typedRoute(source) {
+    return TYPED.exec(source)?.[1];
+}
+function written(node) {
+    if (node === undefined)
+        return undefined;
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+        return node.text;
+    if (ts.isJsxExpression(node) || ts.isParenthesizedExpression(node))
+        return written(node.expression);
+    return undefined;
+}
+function keyed(name) {
+    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
+}
+function attribute(held, name) {
+    for (const one of held.properties) {
+        if (ts.isJsxAttribute(one) && ts.isIdentifier(one.name) && one.name.text === name)
+            return one;
+    }
+    return undefined;
+}
+function property(held, name) {
+    for (const one of held.properties) {
+        if (ts.isPropertyAssignment(one) && keyed(one.name) === name)
+            return one;
+    }
+    return undefined;
+}
+function moveOf(found, wording) {
+    const to = written(found(MOVES));
+    let through;
+    for (const key of wording) {
+        through = written(found(key));
+        if (through !== undefined)
+            break;
+    }
+    return { ...(to === undefined ? {} : { to }), ...(through === undefined ? {} : { through }) };
+}
+export function holding(text, at, wording, placeable) {
+    const file = ts.createSourceFile(at, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const moves = [];
+    const places = new Set();
+    const walk = (node) => {
+        if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+            const tag = node.tagName;
+            if (ts.isIdentifier(tag) && placeable.has(tag.text))
+                places.add(tag.text);
+            if (attribute(node.attributes, MOVES) !== undefined) {
+                moves.push(moveOf((name) => attribute(node.attributes, name)?.initializer, wording));
+            }
+        }
+        if (ts.isObjectLiteralExpression(node) && property(node, MOVES) !== undefined) {
+            moves.push(moveOf((name) => property(node, name)?.initializer, wording));
+        }
+        ts.forEachChild(node, walk);
+    };
+    walk(file);
+    return { moves, places: [...places].sort() };
+}
+function wordingFirst(props) {
+    const first = ['label', 'labelKey'];
+    return [...first.filter((one) => props.includes(one)), ...props.filter((one) => !first.includes(one))];
+}
+function linksOf(at, rows, compositions, routes, wording) {
+    const named = new Map();
+    for (const row of compositions)
+        named.set(compositionOf(row.at), row.at);
+    for (const row of rows)
+        named.set(nameOf(row.at), row.at);
+    const placeable = new Set(named.keys());
+    const screens = [...routes.keys()].sort();
+    const held = new Map();
+    const read = (path) => {
+        const kept = held.get(path);
+        if (kept !== undefined)
+            return kept;
+        const file = join(at, path);
+        const made = existsSync(file) ? holding(readFileSync(file, 'utf8'), path, wording, placeable) : { moves: [], places: [] };
+        held.set(path, made);
+        return made;
+    };
+    const links = [];
+    const stated = new Set();
+    const wrong = [];
+    for (const row of rows) {
+        const from = nameOf(row.at);
+        const seen = new Set();
+        const gather = (path) => {
+            if (seen.has(path))
+                return;
+            seen.add(path);
+            const one = read(path);
+            for (const move of one.moves) {
+                const through = move.through === undefined ? '' : ` through \`${move.through}\``;
+                if (move.to === undefined) {
+                    wrong.push(`${path} moves somebody with a \`${MOVES}\` that is not written out as a screen name, so the map cannot ` +
+                        `say where ${from} goes${through}. Name the screen — \`${MOVES}="${screens[0] ?? 'Home'}"\`.`);
+                    continue;
+                }
+                if (!routes.has(move.to)) {
+                    wrong.push(`${from} goes to \`${move.to}\`${through}, and no screen is called that. The screens are ` +
+                        `${screens.join(', ')} — declare it with \`thread create screen\`, or name one of those.`);
+                    continue;
+                }
+                const link = { from, to: move.to, ...(move.through === undefined ? {} : { labelKey: move.through }) };
+                const key = JSON.stringify(link);
+                if (stated.has(key))
+                    continue;
+                stated.add(key);
+                links.push(link);
+            }
+            for (const place of one.places) {
+                const where = named.get(place);
+                if (where !== undefined)
+                    gather(where);
+            }
+        };
+        gather(row.at);
+    }
+    return { links, wrong };
+}
+const quoted = (value) => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+function mapModule(map) {
+    const screen = (one) => `    { id: ${quoted(one.id)}, nameKey: ${quoted(one.nameKey)}, ` +
+        `${one.path === undefined ? '' : `path: ${quoted(one.path)}, `}` +
+        `entry: ${String(one.entry)}, shows: [${one.shows.map(quoted).join(', ')}] },`;
+    const link = (one) => `    { from: ${quoted(one.from)}, to: ${quoted(one.to)}${one.labelKey === undefined ? '' : `, labelKey: ${quoted(one.labelKey)}`} },`;
+    return [
+        '/* GENERATED by thread — do not edit. It is derived from the screens, and from every navigateTo they and their compositions hold. */',
+        '',
+        `import type { MapIsland } from '${GRAMMAR}'`,
+        '',
+        'export const MAP: MapIsland = {',
+        '  specVersion: 1,',
+        '  screens: [',
+        ...map.screens.map(screen),
+        '  ],',
+        '  links: [',
+        ...map.links.map(link),
+        '  ],',
+        '}',
+        '',
+    ].join('\n');
+}
+function shown(map) {
+    return [
+        ...map.screens.map((one) => one.path === undefined
+            ? `  ${one.id} has no route — a press opens it where somebody already is`
+            : `  ${one.id} answers ${one.path}${one.entry ? ' — the entry, because it is the first page declared' : ''}`),
+        ...map.links.map((one) => `  ${one.from} → ${one.to}${one.labelKey === undefined ? '' : `, through ${one.labelKey}`}`),
+        ...map.screens
+            .filter((one) => !one.entry && !map.links.some((link) => link.to === one.id))
+            .map((one) => one.path === undefined
+            ? `  ${one.id} — no button goes there, and a screen with no route is reached no other way`
+            : `  ${one.id} — no button goes there, so it is reached only by its address ${one.path}`),
+    ];
+}
+function reaching(file, at) {
+    const up = '../'.repeat(file.split('/').length - 1);
+    return `${up}${at.replace(/\.tsx?$/, '')}`;
+}
+function page(name, at, route) {
+    const from = reaching(pageAt(route), at);
+    return [
+        '/* GENERATED by thread — do not edit. It follows from the screen\'s name and its place among the pages. */',
+        '',
+        `import { ${name} } from '${from}'`,
+        '',
+        'export default function Page() {',
+        `  return <${name} />`,
+        '}',
+        '',
+    ].join('\n');
+}
+function guarding(checker) {
+    if (checker === undefined) {
+        return [
+            "throw new Error('thread: the compiler that checks this tree cannot be found, so nothing here " +
+                "can be compiled. Reinstall the framework packages. A check that cannot run is not a check " +
+                "that passed.')",
+            '',
+        ];
+    }
+    return [
+        "import { ungated } from './react.ts'",
+        '',
+        "const why = ungated(`${process.cwd()}/app/layout.tsx`)",
+        'if (why !== null) throw new Error(`thread: ${why}`)',
+        '',
+    ];
+}
+function layout(wording, icons, source, checker, knowing, doored) {
+    return [
+        '/* GENERATED by thread — do not edit. It is derived from what the other generators produce. */',
+        '',
+        '/// <reference types="next/types/global" />',
+        '',
+        ...guarding(checker),
+        "import type { ReactNode } from 'react'",
+        ...(doored ? ["import { Door } from './_generated/door.tsx'"] : [`import { ThreadUi } from '${PROVIDER}'`]),
+        ...(doored ? [] : ["import { ASKING } from './_generated/declared.ts'"]),
+        ...(knowing
+            ? ["import { headers } from 'next/headers'", `import { actor } from '../${DECLARED}'`]
+            : []),
+        "import './_generated/tokens.css'",
+        ...(icons ? ["import { ThreadIcons } from './_generated/icons.ts'"] : []),
+        ...(wording && !doored ? ["import { SOURCE, WORDING } from './_generated/wording.ts'"] : []),
+        '',
+        knowing
+            ? 'export default async function RootLayout({ children }: { children: ReactNode }) {'
+            : 'export default function RootLayout({ children }: { children: ReactNode }) {',
+        ...(knowing
+            ? ["  const who = await actor(new Request('http://localhost', { headers: await headers() }))"]
+            : []),
+        '  return (',
+        `    <html lang="${source}">`,
+        '      <body>',
+        ...(icons ? ['        <ThreadIcons />'] : []),
+        doored
+            ? `        <Door${knowing ? ' actor={who}' : ''}>{children}</Door>`
+            : `        <ThreadUi asking={ASKING}${knowing ? ' actor={who}' : ''}${wording ? ' locale={SOURCE} wording={WORDING}' : ''}>{children}</ThreadUi>`,
+        '      </body>',
+        '    </html>',
+        '  )',
+        '}',
+        '',
+    ].join('\n');
+}
+const CONFIG = `next.config.${'js'}`;
+const SHADOWS = [`next.config.${'mjs'}`, `next.config.${'ts'}`, `next.config.${'mts'}`];
+function rootFor(at) {
+    let real;
+    try {
+        real = realpathSync(join(at, 'node_modules', packageOf('ui')));
+    }
+    catch {
+        return undefined;
+    }
+    const here = realpathSync(at);
+    if (real.startsWith(`${here}/`))
+        return undefined;
+    const one = here.split('/');
+    const two = real.split('/');
+    const shared = [];
+    for (let step = 0; step < Math.min(one.length, two.length); step += 1) {
+        if (one[step] !== two[step])
+            break;
+        shared.push(one[step] ?? '');
+    }
+    const common = shared.join('/');
+    return relative(here, common) || '.';
+}
+function loaderFor(at) {
+    try {
+        return realpathSync(join(at, 'node_modules', packageOf('ui'), 'dist', 'generators', 'react.js'));
+    }
+    catch {
+        return undefined;
+    }
+}
+const DRIVER = /export\s+const\s+driver\s*:[^=\n]*=\s*\[([^\]]*)\]/;
+const QUOTED = /'([^']+)'|"([^"]+)"/g;
+const RELATIVE = /(?:^|[\s;{(])import\s+(?!type\s)(?:[\w*{][^'"]*from\s+)?['"](\.[^'"]+)['"]/g;
+function externalFor(at) {
+    const wiring = join(at, DECLARED);
+    if (!existsSync(wiring))
+        return [];
+    const read = (path) => {
+        try {
+            return readFileSync(path, 'utf8');
+        }
+        catch {
+            return '';
+        }
+    };
+    const found = new Set();
+    const wiredIn = read(wiring);
+    const reachable = [...wiredIn.matchAll(RELATIVE)].map(([, one]) => {
+        const path = join(dirname(wiring), (one ?? '').replace(/\.tsx?$/, '')) + '.ts';
+        return [path, read(path)];
+    });
+    const SEAM = /export\s+const\s+store\s*:/;
+    for (const [where, text] of [[wiring, wiredIn], ...reachable]) {
+        const held = DRIVER.exec(text)?.[1];
+        if (held === undefined) {
+            if (where === wiring || !SEAM.test(text))
+                continue;
+            stderr.write(`routes: ${relative(at, where)} declares a store and does not say what must stay out of the bundle. ` +
+                'A store opens something, and a config written without that entry breaks where the driver is used rather ' +
+                "than here. Re-run the command that writes it — if it is older than the `driver` export, that is what is " +
+                'missing.\n');
+            exit(1);
+        }
+        for (const [, single, double] of held.matchAll(QUOTED)) {
+            const one = single ?? double;
+            if (one !== undefined && one !== '')
+                found.add(one);
+        }
+    }
+    return [...found].sort();
+}
+function builtAs(loader) {
+    try {
+        const held = JSON.parse(readFileSync(join(dirname(loader), '..', '..', 'package.json'), 'utf8'));
+        return held.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function config(root, loader, external) {
+    const turbopack = [
+        ...(root === undefined ? [] : [`    root: join(import.meta.dirname, ${JSON.stringify(root)}),`]),
+        ...(loader === undefined
+            ? []
+            : [
+                '    rules: {',
+                `      '**/*.tsx': { loaders: [{ loader: ${JSON.stringify(loader)}, options: ${JSON.stringify({ built: builtAs(loader) })} }] },`,
+                '    },',
+            ]),
+    ];
+    const gate = loader === undefined
+        ? [
+            "throw new Error('thread: the compiler that checks this tree cannot be found, so nothing here " +
+                "can be compiled. Reinstall the framework packages. A check that cannot run is not a check " +
+                "that passed.')",
+            '',
+        ]
+        : [
+            `import { ungated } from ${JSON.stringify(loader)}`,
+            '',
+            'const why = ungated(import.meta.filename)',
+            'if (why !== null) throw new Error(`thread: ${why}`)',
+            '',
+        ];
+    return [
+        '/* GENERATED by thread — do not edit. It is derived from where the packages resolve. */',
+        '',
+        ...(root === undefined ? [] : ["import { join } from 'node:path'", '']),
+        ...gate,
+        'export default {',
+        ...(turbopack.length === 0 ? [] : ['  turbopack: {', ...turbopack, '  },']),
+        ...(external.length === 0
+            ? []
+            : [`  serverExternalPackages: [${external.map((one) => JSON.stringify(one)).join(', ')}],`]),
+        '  agentRules: false,',
+        '}',
+        '',
+    ].join('\n');
+}
+async function run() {
+    const tree = findTree();
+    const at = tree.at;
+    const screensAt = inTree(tree, `screens.${'ts'}`);
+    if (!existsSync(screensAt)) {
+        stdout.write(`routes: this tree has no ${relative(at, screensAt)}, so it declares no screen and there is no map, page or layout to write or check.\n`);
+        return 0;
+    }
+    const sheet = (await import(__rewriteRelativeImportExtension(pathToFileURL(screensAt).href)));
+    if (sheet.SCREEN === undefined) {
+        stderr.write('routes: _threads/screens.ts exports no `SCREEN`, so nothing declares a screen here.\n');
+        return 1;
+    }
+    const held = (await import(__rewriteRelativeImportExtension(pathToFileURL(inTree(tree, `localizations.${'ts'}`)).href)).catch(() => ({})));
+    const source = held.LOCALIZATION?.holds?.find((one) => one.id === 'source')?.is ?? 'en';
+    const placed = (await import(__rewriteRelativeImportExtension(pathToFileURL(inTree(tree, `compositions.${'ts'}`)).href)).catch(() => ({})));
+    const compositions = placed.COMPOSITION?.declares ?? [];
+    const rows = sheet.SCREEN.declares ?? [];
+    const texts = new Map();
+    for (const row of rows) {
+        const file = join(at, row.at);
+        if (!existsSync(file)) {
+            stderr.write(`routes: \`${row.id}\` is declared at \`${row.at}\` and the file is not there. Run \`thread screens\`.\n`);
+            return 1;
+        }
+        texts.set(row.id, readFileSync(file, 'utf8'));
+    }
+    const shownOf = (id) => presentedIn(texts.get(id) ?? '');
+    const entry = entryAmong(rows, shownOf);
+    const made = [];
+    const routes = new Map();
+    const screens = [];
+    for (const row of rows) {
+        const text = texts.get(row.id) ?? '';
+        const typed = typedRoute(text);
+        if (typed !== undefined) {
+            stderr.write(`routes: ${row.at} states \`route: '${typed}'\`, and a route is never typed: the first page an app declares ` +
+                'answers `/`, every other page answers its own name, and a sheet has no route. Take `route:` out of the ' +
+                'file — `thread create screen edit` rewrites it without one when it is given the body.\n');
+            return 1;
+        }
+        const name = nameOf(row.at);
+        const shownAs = shownOf(row.id);
+        if (!PRESENTATIONS.includes(shownAs)) {
+            stderr.write(`routes: ${row.at} is presented as \`${shownAs}\`, and a presentation is not a free word: it is one of ` +
+                `${PRESENTATIONS.join(', ')}, because each carries a settled behaviour for portalling, trapping focus and dismissing, ` +
+                'and one that is not among them would compile and behave as none of them. Change the `as:` in that file.\n');
+            return 1;
+        }
+        const route = shownAs === PAGE ? routeFor(row.id, row.id === entry) : undefined;
+        routes.set(name, route);
+        screens.push({
+            id: name,
+            nameKey: `screen.${row.id}`,
+            ...(route === undefined ? {} : { path: route }),
+            entry: row.id === entry,
+            shows: [],
+        });
+        if (route === undefined)
+            continue;
+        const where = pageAt(route);
+        const stated = (row.derives ?? []).find((one) => one.id === 'page')?.at;
+        if (stated !== where) {
+            stderr.write(`routes: \`${row.id}\` answers ${route}, so its page is ${where}, and its row ` +
+                `${stated === undefined ? 'derives no page' : `says ${stated}`}. Run \`thread create screen edit\` on it — ` +
+                'the row is rewritten from where the screen now lives.\n');
+            return 1;
+        }
+        made.push({ path: where, text: page(name, row.at, route) });
+    }
+    const { links, wrong } = linksOf(at, rows, compositions, routes, wordingFirst(keyProps(at)));
+    if (wrong.length > 0) {
+        for (const one of wrong)
+            stderr.write(`routes: ${one}\n`);
+        return 1;
+    }
+    const map = { specVersion: 1, screens, links };
+    made.push({ path: MAP, text: mapModule(map) });
+    made.push({ path: CONFIG, text: config(rootFor(at), loaderFor(at), externalFor(at)) });
+    const dispatching = existsSync(join(at, CLIENT));
+    const moving = rows.length > 0;
+    const doored = dispatching || moving;
+    const presenting = rows
+        .filter((row) => routes.get(nameOf(row.at)) === undefined)
+        .map((row) => ({ name: nameOf(row.at), at: row.at }));
+    if (doored)
+        made.push({ path: DOOR, text: door(existsSync(join(at, DECLARED)), existsSync(join(at, WORDING)), dispatching, moving, presenting) });
+    made.push({
+        path: LAYOUT,
+        text: layout(existsSync(join(at, WORDING)), existsSync(join(at, 'app/_generated/icons.ts')), source, loaderFor(at), existsSync(join(at, DECLARED)), doored),
+    });
+    const paged = map.screens.filter((one) => one.path !== undefined).length;
+    const counted = `${String(map.screens.length)} screen(s), ${String(paged)} route(s), ${String(map.links.length)} link(s)`;
+    if (argv.includes('--check')) {
+        for (const one of SHADOWS) {
+            if (!existsSync(join(at, one)))
+                continue;
+            stderr.write(`routes: ${one} sits beside ${CONFIG}, and Next loads ${CONFIG} because it is the first name it ` +
+                `looks for. Nothing reads ${one} — an edit to it changes nothing and says nothing. Delete it.\n`);
+            return 1;
+        }
+        for (const one of made) {
+            let current = '';
+            try {
+                current = readFileSync(join(at, one.path), 'utf8');
+            }
+            catch {
+                current = '';
+            }
+            if (current === one.text)
+                continue;
+            stderr.write(`routes: ${one.path} is not what the declarations produce. A derived file that differs from its ` +
+                'generator is a hand edit wearing a generated name. Run `thread routes` and commit what it writes.\n');
+            return 1;
+        }
+        stdout.write(`routes: ${String(made.length)} file(s) are what the screens produce — ${counted}\n`);
+        for (const line of shown(map))
+            stdout.write(`${line}\n`);
+        return 0;
+    }
+    for (const one of made) {
+        mkdirSync(dirname(join(at, one.path)), { recursive: true });
+        writeFileSync(join(at, one.path), one.text, 'utf8');
+    }
+    stdout.write(`routes: the map — ${counted}\n`);
+    for (const line of shown(map))
+        stdout.write(`${line}\n`);
+    stdout.write(`routes: wrote ${String(paged)} page(s), the map and the layout\n`);
+    return 0;
+}
+if (invoked(import.meta.url))
+    exit(await run());

package/dist/ui/generators/show.d.ts

@@ -0,0 +1 @@
+export declare function namedBy(id: string): Promise<readonly string[]>;