@prestack/thread-ui 0.1.9 → 0.1.11

package/dist/ui/generators/routes.ts

@@ -1,847 +0,0 @@
-import { dirname, join, relative } from 'node:path'
-import { argv, stderr, stdout } from 'node:process'
-
-import ts from 'typescript'
-
-import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from '@prestack/thread/integrations/disk'
-import { exit, invoked } from '@prestack/thread/core/invoked'
-import { listBounds, nestedBounds, rowsIn, valuesIn, withField, withRow, withoutField, withoutRow } 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 { said } from '@prestack/thread/operations/attach'
-import { ACTOR_AT, COMPILED } from '@prestack/thread/operations/capabilities'
-
-import { 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/reaching.' + '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 PAGE_ROW = 'page'
-
-const WRITER = 'thread routes'
-
-const PAGE_SAID =
-  'The page a browser gets at the address of this screen: `/` when it is the first page this app declares, and its own ' +
-  'name otherwise. `thread routes` writes the page and this row from where the screen sits, and moves or deletes both ' +
-  'when that changes.'
-
-function served(at: string): boolean {
-  try {
-    const held = JSON.parse(readFileSync(join(at, 'package.json'), 'utf8')) as {
-      scripts?: Readonly<Record<string, string>>
-    }
-    return Object.values(held.scripts ?? {}).some((one) => /(?:^|[\s;&|])next(?:\s|$)/.test(one))
-  } catch {
-    return false
-  }
-}
-
-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'",
-    '',
-    ...(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 [
-    `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 [
-    `import { ${name} } from '${from}'`,
-    '',
-    'export default function Page() {',
-    `  return <${name} />`,
-    '}',
-    '',
-  ].join('\n')
-}
-
-interface Repaged {
-  readonly id: string
-  readonly shown: string
-  readonly route: string | undefined
-  readonly was: string | undefined
-  readonly where: string | undefined
-}
-
-const pageShaped = (path: string): boolean => path === pageAt(`/${path.split('/').slice(1, -1).join('/')}`)
-
-function unpaged(one: Repaged): string {
-  if (one.where === undefined) {
-    return (
-      `\`${one.id}\` is presented as a ${one.shown}, so it has no page, and its row still derives ${String(one.was)}. ` +
-      `Run \`${WRITER}\`, which takes that row out and deletes the page.`
-    )
-  }
-  return (
-    `\`${one.id}\` answers ${String(one.route)}, so its page is ${one.where}, and its row ` +
-    `${one.was === undefined ? 'derives no page' : `says ${one.was}`}. Run \`${WRITER}\`, which writes that row from ` +
-    'where the screen now sits and puts the page there.'
-  )
-}
-
-function repaged(text: string, moved: readonly Repaged[]): string | undefined {
-  let next = text
-  for (const one of moved) {
-    const list = listBounds(next, 'declares')
-    const inside = list === undefined ? undefined : nestedBounds(next, list, one.id, 'derives')
-    if (inside !== undefined) next = withoutRow(next, inside, PAGE_ROW)
-    const rows = listBounds(next, 'declares')
-    if (rows === undefined) return undefined
-    const within = nestedBounds(next, rows, one.id, 'derives')
-    if (one.where === undefined) {
-      if (within !== undefined && rowsIn(next, within).length === 0) next = withoutField(next, rows, one.id, 'derives')
-      continue
-    }
-    const row = said({ id: PAGE_ROW, at: one.where, describes: PAGE_SAID, version: 1, by: WRITER, runs: `${WRITER} --check` }, '        ')
-    const put = within === undefined ? withField(next, rows, one.id, 'derives', `[\n${row}\n      ]`) : withRow(next, within, row)
-    if (put === undefined) return undefined
-    next = put
-  }
-  return next
-}
-
-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 ' +",
-    "      'thread dev, which runs it before anything is served. 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 [
-    ...gate(true),
-    "import type { ReactNode } from 'react'",
-    "import type {} from 'next'",
-    ...(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 '../${ACTOR_AT}'`]
-      : []),
-
-    "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 STORE = /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 || !STORE.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 [
-    ...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[]
-}
-
-function landed(at: string, made: readonly { readonly path: string; readonly text: string }[]): number | undefined {
-  if (!argv.includes('--check')) {
-    for (const one of made) writeFileSync(join(at, one.path), one.text, 'utf8')
-    return undefined
-  }
-
-  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
-  }
-
-  return undefined
-}
-
-async function run(): Promise<number> {
-  const tree = findTree()
-  const at = tree.at
-
-  const screensAt = inTree(tree, `screens.${'ts'}`)
-  if (!existsSync(screensAt)) {
-    if (!served(at)) {
-      stdout.write(
-        `routes: this tree has no ${relative(at, screensAt)} and its manifest runs no page server, so it declares ` +
-          'no screen and there is nothing to write or check.\n',
-      )
-      return 0
-    }
-
-    const only = [{ path: CONFIG, text: config(rootFor(at), externalFor(at)) }]
-    const refused = landed(at, only)
-    if (refused !== undefined) return refused
-    stdout.write(
-      `routes: ${CONFIG} ${argv.includes('--check') ? 'is what the declarations produce' : 'written'} — this tree ` +
-        `declares no screen, and Next serves it all the same.\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 moved: Repaged[] = []
-  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 with \`thread edit ${row.at} --find <text> --replace <text>\`, which changes that one stretch of it.\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],
-    })
-    const where = route === undefined ? undefined : pageAt(route)
-    const was = (row.derives ?? []).find((one) => one.id === PAGE_ROW)?.at
-    if (was !== where) moved.push({ id: row.id, shown: shownAs, route, was, where })
-    if (route === undefined || where === undefined) continue
-    made.push({ path: where, text: page(name, row.at, route) })
-  }
-
-  if (moved.length > 0 && argv.includes('--check')) {
-    for (const one of moved) stderr.write(`routes: ${unpaged(one)}\n`)
-    return 1
-  }
-
-  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, ACTOR_AT)), 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, ACTOR_AT)),
-      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 (moved.length > 0) {
-    const declaredIn = relative(at, screensAt)
-    const rewritten = repaged(readFileSync(screensAt, 'utf8'), moved)
-    if (rewritten === undefined) {
-      stderr.write(
-        `routes: ${declaredIn} could not be given the page row of each screen, so nothing was written. ` +
-          `\`thread read ${declaredIn}\` prints what it states now.\n`,
-      )
-      return 1
-    }
-    writeFileSync(screensAt, rewritten, 'utf8')
-    const answered = new Set(made.map((one) => one.path))
-    const home = dirname(join(at, pageAt('/')))
-    for (const one of moved) {
-      stdout.write(
-        one.where === undefined
-          ? `routes: \`${one.id}\` has no route, so its row no longer derives ${String(one.was)}\n`
-          : `routes: \`${one.id}\` answers ${String(one.route)}, so its row now derives ${one.where}\n`,
-      )
-      if (one.was === undefined || answered.has(one.was) || !pageShaped(one.was) || !existsSync(join(at, one.was))) continue
-      rmSync(join(at, one.was))
-      const folder = dirname(join(at, one.was))
-      if (folder !== home && readdirSync(folder).length === 0) rmSync(folder, { recursive: true, force: true })
-      stdout.write(`routes: deleted ${one.was}, because no screen answers there any more\n`)
-    }
-  }
-
-  const refused = landed(at, made)
-  if (refused !== undefined) return refused
-
-  if (argv.includes('--check')) {
-    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
-  }
-  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())