@prestack/thread-ui 0.0.1 → 0.1.0

package/dist/ui/generators/routes.ts

@@ -0,0 +1,743 @@
+import { dirname, join, relative } from 'node:path'
+import { argv, stderr, stdout } from 'node:process'
+
+import ts from 'typescript'
+
+import { existsSync, readFileSync, realpathSync, writeFileSync } from '@prestack/thread/core/files'
+import { exit, invoked } from '@prestack/thread/core/invoked'
+import { valuesIn } from '@prestack/thread/core/rows'
+import { named as packageOf } from '@prestack/thread/core/scope'
+import { findTree, inTree } from '@prestack/thread/core/tree'
+import { PERMITS_AT } from '@prestack/thread/operations/access'
+
+import { COMPILED, compiledAt, nameOf as compositionOf } from '../compositions.ts'
+import { PRESENTATIONS } from '../door.ts'
+import type { MapIsland } from '../islands/map.ts'
+import { PAGE, entryAmong, nameOf, pageAt, presentedIn, routeFor } from '../screens.ts'
+
+import { keyProps } from './i18n.ts'
+
+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 = `${COMPILED}/ui/provider.tsx`
+
+const GRAMMAR = `${COMPILED}/ui/islands/map.ts`
+
+const MOVES = 'navigateTo'
+
+const sheetAt = (at: string): Record<string, unknown> => {
+  if (!existsSync(at)) return {}
+  return valuesIn(readFileSync(at)) as Record<string, unknown>
+}
+
+function door(
+  knowing: boolean,
+  wording: boolean,
+  dispatching: boolean,
+  moving: boolean,
+  presenting: readonly { readonly name: string; readonly at: string }[],
+): string {
+  const opening = presenting.length > 0
+  const props =
+    `asking={ASKING}${knowing ? ' actor={actor} permits={gate}' : ''}${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 || knowing
+      ? [
+          `import { useCallback, ${moving && opening ? 'useState, ' : ''}type ReactNode } from 'react'`,
+          ...(moving ? ["import { useRouter } from 'next/navigation'"] : []),
+        ]
+      : ["import type { ReactNode } from 'react'"]),
+    '',
+    `import { ThreadUi } from '${reaching(DOOR, PROVIDER)}'`,
+    '',
+    "import { ASKING } from './declared.ts'",
+    ...(knowing ? [`import { permits } from '${reaching(DOOR, PERMITS_AT)}'`] : []),
+    ...(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, compiledAt(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',
+    '}) {',
+    ...(knowing
+      ? [
+          '  const gate = useCallback(',
+          '    (action: string): boolean => (actor === undefined ? false : permits(actor, action, null).allow),',
+          '    [actor],',
+          '  )',
+        ]
+      : []),
+    ...(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')
+}
+
+interface Row {
+  readonly id: string
+  readonly at: string
+  readonly describes?: string
+  readonly derives?: readonly { readonly id: string; readonly at: string }[]
+}
+
+const TYPED = /screen\(\s*'[^']*'\s*,\s*\{[^}]*route:\s*'([^']*)'/
+
+export function typedRoute(source: string): string | undefined {
+  return TYPED.exec(source)?.[1]
+}
+
+const SHOWING = /screen\(\s*'[^']*'\s*,\s*\{[^}]*views:\s*\[([^\]]*)\]/
+
+export function viewsIn(source: string): readonly string[] {
+  const held = SHOWING.exec(source)?.[1]
+  if (held === undefined) return []
+  return [...held.matchAll(QUOTED)].map(([, single, double]) => single ?? double ?? '').filter((one) => one !== '')
+}
+
+const VIEW = /^vw_[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/
+
+const OPERATION = /operation:\s*"([^"]+)"/g
+
+function reachable(at: string): readonly string[] {
+  const held = join(at, CLIENT)
+  if (!existsSync(held)) return []
+  return [...readFileSync(held, 'utf8').matchAll(OPERATION)].map(([, one]) => one ?? '')
+}
+
+interface Move {
+  readonly to?: string
+  readonly through?: string
+}
+
+interface Holding {
+  readonly moves: readonly Move[]
+  readonly places: readonly string[]
+}
+
+function written(node: ts.Node | undefined): string | undefined {
+  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: ts.PropertyName): string | undefined {
+  return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined
+}
+
+function attribute(held: ts.JsxAttributes, name: string): ts.JsxAttribute | undefined {
+  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: ts.ObjectLiteralExpression, name: string): ts.PropertyAssignment | undefined {
+  for (const one of held.properties) {
+    if (ts.isPropertyAssignment(one) && keyed(one.name) === name) return one
+  }
+  return undefined
+}
+
+function moveOf(found: (name: string) => ts.Node | undefined, wording: readonly string[]): Move {
+  const to = written(found(MOVES))
+  let through: string | undefined
+  for (const key of wording) {
+    through = written(found(key))
+    if (through !== undefined) break
+  }
+  return { ...(to === undefined ? {} : { to }), ...(through === undefined ? {} : { through }) }
+}
+
+export function holding(text: string, at: string, wording: readonly string[], placeable: ReadonlySet<string>): Holding {
+  const file = ts.createSourceFile(at, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
+  const moves: Move[] = []
+  const places = new Set<string>()
+
+  const walk = (node: ts.Node): void => {
+    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: readonly string[]): readonly string[] {
+  const first = ['label', 'labelKey']
+  return [...first.filter((one) => props.includes(one)), ...props.filter((one) => !first.includes(one))]
+}
+
+function linksOf(
+  at: string,
+  rows: readonly Row[],
+  compositions: readonly Row[],
+  routes: ReadonlyMap<string, string | undefined>,
+  wording: readonly string[],
+): { readonly links: MapIsland['links']; readonly wrong: readonly string[] } {
+  const named = new Map<string, string>()
+  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<string, Holding>()
+  const read = (path: string): Holding => {
+    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: MapIsland['links'][number][] = []
+  const stated = new Set<string>()
+  const wrong: string[] = []
+
+  for (const row of rows) {
+    const from = nameOf(row.at)
+    const seen = new Set<string>()
+    const gather = (path: string): void => {
+      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: string): string => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+
+function mapModule(map: MapIsland): string {
+  const screen = (one: MapIsland['screens'][number]): string =>
+    `    { 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: MapIsland['links'][number]): string =>
+    `    { 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 '${reaching(MAP, GRAMMAR)}'`,
+    '',
+    'export const MAP: MapIsland = {',
+    '  specVersion: 1,',
+    '  screens: [',
+    ...map.screens.map(screen),
+    '  ],',
+    '  links: [',
+    ...map.links.map(link),
+    '  ],',
+    '}',
+    '',
+  ].join('\n')
+}
+
+function shown(map: MapIsland): readonly string[] {
+  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: string, at: string): string {
+  const up = '../'.repeat(file.split('/').length - 1)
+  return `${up}${at.replace(/\.tsx?$/, '')}`
+}
+
+function page(name: string, at: string, route: string): string {
+  const from = reaching(pageAt(route), compiledAt(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 gate(typed: boolean): readonly string[] {
+  const said = typed ? ' as { of?: Record<string, string> }' : ''
+  return [
+    "import { createHash } from 'node:crypto'",
+    "import { existsSync, readFileSync, statSync } from 'node:fs'",
+    "import { join } from 'node:path'",
+    '',
+    "const receipt = join(process.cwd(), '.thread', 'gate.json')",
+    'if (!existsSync(receipt)) {',
+    '  throw new Error(',
+    "    'thread: this tree has no passing gate, so nothing in it may compile. Run `thread gate` — or the ' +",
+    "      'dev, build and start scripts, which run it for you. A gate that has never run is not a gate that passed.',",
+    '  )',
+    '}',
+    "const passed = Symbol.for('thread.gate')",
+    "const stamp = String(statSync(receipt).mtimeMs) + ':' + String(statSync(receipt).size)",
+    'if (Reflect.get(globalThis, passed) !== stamp) {',
+    `  const measured = JSON.parse(readFileSync(receipt, 'utf8'))${said}`,
+    '  for (const [named, was] of Object.entries(measured.of ?? {})) {',
+    '    const at = join(process.cwd(), named)',
+    "    const now = existsSync(at) ? createHash('sha256').update(readFileSync(at)).digest('hex').slice(0, 16) : 'gone'",
+    '    if (now === was) continue',
+    '    throw new Error(',
+    "      'thread: ' + named + ' has changed since the gate last passed, so what this tree declares and what ' +",
+    "        'it was measured as no longer agree. Run `thread gate`',",
+    '    )',
+    '  }',
+    '  Reflect.set(globalThis, passed, stamp)',
+    '}',
+    '',
+  ]
+}
+
+function layout(
+  wording: boolean,
+  icons: boolean,
+  source: string,
+  knowing: boolean,
+  doored: boolean,
+): string {
+  return [
+    '/* GENERATED by thread — do not edit. It is derived from what the other generators produce. */',
+    '',
+    '/// <reference types="next/types/global" />',
+    '',
+    ...gate(true),
+    "import type { ReactNode } from 'react'",
+    ...(doored ? ["import { Door } from './_generated/door.tsx'"] : [`import { ThreadUi } from '${reaching(LAYOUT, 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: readonly string[] = [`next.config.${'mjs'}`, `next.config.${'ts'}`, `next.config.${'mts'}`]
+
+function rootFor(at: string): string | undefined {
+  let real: string
+  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: string[] = []
+  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) || '.'
+}
+
+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: string): readonly string[] {
+  const wiring = join(at, DECLARED)
+  if (!existsSync(wiring)) return []
+
+  const read = (path: string): string => {
+    try {
+      return readFileSync(path, 'utf8')
+    } catch {
+      return ''
+    }
+  }
+
+  const found = new Set<string>()
+  const wiredIn = read(wiring)
+
+  const reachable = [...wiredIn.matchAll(RELATIVE)].map(([, one]) => {
+    const path = join(dirname(wiring), (one ?? '').replace(/\.tsx?$/, '')) + '.ts'
+    return [path, read(path)] as const
+  })
+
+  const SEAM = /export\s+const\s+store\s*:/
+
+  for (const [where, text] of [[wiring, wiredIn] as const, ...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 config(root: string | undefined, external: readonly string[]): string {
+  const turbopack = [
+    ...(root === undefined ? [] : [`    root: join(import.meta.dirname, ${JSON.stringify(root)}),`]),
+  ]
+
+  return [
+    '/* GENERATED by thread — do not edit. It is derived from where the packages resolve. */',
+    '',
+    ...gate(false),
+    'export default {',
+    ...(turbopack.length === 0 ? [] : ['  turbopack: {', ...turbopack, '  },']),
+
+    ...(external.length === 0
+      ? []
+      : [`  serverExternalPackages: [${external.map((one) => JSON.stringify(one)).join(', ')}],`]),
+    '  agentRules: false,',
+    '}',
+    '',
+  ].join('\n')
+}
+
+interface Node {
+  readonly declares?: readonly Row[]
+}
+
+async function run(): Promise<number> {
+  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 = valuesIn(readFileSync(screensAt)) as { SCREEN?: Node }
+  if (sheet.SCREEN === undefined) {
+    stderr.write('routes: _threads/screens.ts exports no `SCREEN`, so nothing declares a screen here.\n')
+    return 1
+  }
+
+  const held = sheetAt(inTree(tree, `localizations.${'ts'}`)) as {
+    LOCALIZATION?: { readonly holds?: readonly { readonly id: string; readonly is?: string }[] }
+  }
+  const source = held.LOCALIZATION?.holds?.find((one) => one.id === 'source')?.is ?? 'en'
+
+  const placed = sheetAt(inTree(tree, `compositions.${'ts'}`)) as {
+    COMPOSITION?: Node
+  }
+  const compositions = placed.COMPOSITION?.declares ?? []
+
+  const rows = sheet.SCREEN.declares ?? []
+  const texts = new Map<string, string>()
+  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: string): string => presentedIn(texts.get(id) ?? '')
+  const entry = entryAmong(rows, shownOf)
+
+  const made: { readonly path: string; readonly text: string }[] = []
+  const routes = new Map<string, string | undefined>()
+  const screens: MapIsland['screens'][number][] = []
+  const reaches = reachable(at)
+
+  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 as readonly string[]).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)
+    const shows = viewsIn(text)
+    for (const one of shows) {
+      if (!VIEW.test(one)) {
+        stderr.write(
+          `routes: ${row.at} shows \`${one}\`, and that is not the name of a view. A view is ` +
+            '`vw_` and then lower case words joined by underscores. A screen names a declared read, ' +
+            'and never states what the read does.\n',
+        )
+        return 1
+      }
+      if (!reaches.includes(one)) {
+        stderr.write(
+          `routes: ${row.at} shows \`${one}\`, and this app reaches no operation by that name. It reaches ` +
+            `${reaches.length === 0 ? 'nothing yet — \`thread capabilities\` writes that list, and the settle runs it before this' : reaches.join(', ')}. Declare the view with ` +
+            '`thread create operation`, or name one of those.\n',
+        )
+        return 1
+      }
+    }
+    screens.push({
+      id: name,
+      nameKey: `screen.${row.id}`,
+      ...(route === undefined ? {} : { path: route }),
+      entry: row.id === entry,
+      shows: [...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: MapIsland = { specVersion: 1, screens, links }
+  made.push({ path: MAP, text: mapModule(map) })
+
+  made.push({ path: CONFIG, text: config(rootFor(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,
+      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) {
+    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())