@prestack/thread-ui 0.1.9 → 0.1.11

package/dist/ui/material.ts

@@ -1,236 +0,0 @@
-import { held, naming, sheeted, type Holds, type Token, type Wearing } from './token.ts'
-
-export interface Setting {
-  readonly property: string
-
-  readonly is?: string
-
-  readonly token?: string
-
-  readonly asks?: Readonly<Record<string, string | number>>
-}
-
-export const BOUND = {
-  background: ['colour', 'gradient', 'texture', 'noise', 'img'],
-  backgroundImage: ['gradient', 'texture', 'noise', 'img'],
-  backdropFilter: ['blur'],
-  borderWidth: ['edge'],
-  borderStyle: ['line'],
-  borderColor: ['colour'],
-  boxShadow: ['shadow'],
-  color: ['colour'],
-  opacity: ['opacity'],
-} as const
-
-type Property = keyof typeof BOUND
-
-type MaterialSettingFor<P extends Property> = {
-  readonly property: P
-
-  readonly is?: string
-
-  readonly token?: (typeof BOUND)[P][number]
-
-  readonly asks?: Readonly<Record<string, string | number>>
-}
-
-type MaterialSetting = { [P in Property]: MaterialSettingFor<P> }[Property]
-
-export interface Material {
-  readonly id: string
-
-  readonly sets: readonly MaterialSetting[]
-
-  readonly states?: readonly {
-    readonly when: readonly string[]
-    readonly sets: readonly MaterialSetting[]
-  }[]
-
-  readonly plays?: string
-
-  readonly keyframes?: readonly {
-    readonly id: string
-    readonly sets: Readonly<Record<string, readonly MaterialSetting[]>>
-  }[]
-}
-
-export const FREE = ['transition', 'outline'] as const
-
-export const material = <const T extends Material>(
-  one: T & {
-    readonly sets: {
-      readonly [I in keyof T['sets']]: T['sets'][I] extends { readonly is: infer Said }
-        ? { readonly is: Wearing<Said & string> }
-        : unknown
-    }
-  } & (T extends { readonly states: infer States }
-    ? {
-        readonly states: {
-          readonly [S in keyof States]: States[S] extends { readonly sets: infer Sets }
-            ? {
-                readonly sets: {
-                  readonly [I in keyof Sets]: Sets[I] extends { readonly is: infer Said }
-                    ? { readonly is: Wearing<Said & string> }
-                    : unknown
-                }
-              }
-            : unknown
-        }
-      }
-    : unknown) &
-    (T extends { readonly keyframes: infer Frames }
-      ? {
-          readonly keyframes: {
-            readonly [F in keyof Frames]: Frames[F] extends { readonly sets: infer Stops }
-              ? {
-                  readonly sets: {
-                    readonly [Stop in keyof Stops]: {
-                      readonly [I in keyof Stops[Stop]]: Stops[Stop][I] extends { readonly is: infer Said }
-                        ? { readonly is: Wearing<Said & string> }
-                        : unknown
-                    }
-                  }
-                }
-              : unknown
-          }
-        }
-      : unknown),
-): T => one
-
-function rowsIn(value: string): readonly string[] {
-  return value.split(/\s+/).filter((one) => one !== '')
-}
-
-function bounded(
-  set: Setting,
-  by: string,
-  kinds: Readonly<Record<string, string>>,
-  bound: Readonly<Record<string, readonly string[]>>,
-): void {
-  const value = set.is ?? ''
-
-  const rows = rowsIn(value)
-
-  const allowed = bound[set.property]
-  if (allowed === undefined) return
-
-  for (const row of rows) {
-    const kind = kinds[row]
-    if (kind === undefined || allowed.includes(kind)) continue
-    const list = allowed.map((one) => `\`${one}\``).join(' · ')
-    throw new Error(
-      `\`${by}\` sets \`${set.property}\` to \`${row}\`, and \`${row}\` is a \`${kind}\` row. ` +
-        `\`${set.property}\` takes: ${list}.`,
-    )
-  }
-}
-
-function valued(
-  set: Setting,
-  named: ReadonlySet<string>,
-  tokens: Readonly<Record<string, Token>>,
-  by: string,
-  kinds: Readonly<Record<string, string>> | undefined,
-  bound: Readonly<Record<string, readonly string[]>>,
-): Holds {
-  if (set.is !== undefined && set.token !== undefined) {
-    throw new Error(
-      `\`${by}\` states both a value and a token for \`${set.property}\`. A property is either a ` +
-        'value the style guide holds or a token asked for one, never both.',
-    )
-  }
-
-  if (set.is !== undefined) {
-    if (kinds !== undefined) bounded(set, by, kinds, bound)
-    return naming(named, set.is, by, set.property)
-  }
-
-  if (set.token === undefined) {
-    throw new Error(
-      `\`${by}\` sets \`${set.property}\` to nothing. State a value with \`is\`, or name a token ` +
-        'and what to ask it for.',
-    )
-  }
-
-  const token = tokens[set.token]
-  if (token === undefined) {
-    throw new Error(
-      `\`${by}\` asks \`${set.token}\` for \`${set.property}\`, and no token by that name is ` +
-        'declared. A token has to exist before anything can ask it for a value.',
-    )
-  }
-
-  if (token.makes === undefined) {
-    throw new Error(
-      `\`${by}\` asks \`${set.token}\` for \`${set.property}\`, and \`${set.token}\` carries no ` +
-        'rule, so there is nothing to ask. Name a style guide value instead.',
-    )
-  }
-
-  return held(named, token.makes(set.asks ?? {}), by)
-}
-
-export function composed(
-  sets: readonly Setting[],
-  named: ReadonlySet<string>,
-  tokens: Readonly<Record<string, Token>>,
-  by: string,
-  kinds: Readonly<Record<string, string>>,
-  bound: Readonly<Record<string, readonly string[]>>,
-): Readonly<Record<string, Holds>> {
-  const made: Record<string, Holds> = {}
-  for (const set of sets) {
-
-    if (bound[set.property] === undefined && (set.property === 'animation' || set.property === 'animationName')) {
-      throw new Error(
-        `\`${by}\` sets \`${set.property}\` itself, which buries the keyframes name inside a ` +
-          'string where nothing can check it. Name a style guide row of the `animation` kind, or ' +
-          'declare keyframes and name them with `plays`.',
-      )
-    }
-    made[set.property] = valued(set, named, tokens, by, kinds, bound)
-  }
-  return made
-}
-
-function playing(material: Material, plays: string | undefined): Readonly<Record<string, Holds>> {
-  if (plays === undefined) return {}
-  if ((material.keyframes ?? []).some((one) => one.id === plays)) return { animationName: sheeted(material.id, plays) }
-  const declared = (material.keyframes ?? []).map((one) => one.id)
-  throw new Error(
-    `\`${material.id}\` plays \`${plays}\`, and declares no keyframes by that name. ` +
-      (declared.length === 0
-        ? 'It declares none at all, so there is nothing for it to play.'
-        : `It declares: ${declared.join(' · ')}.`),
-  )
-}
-
-export function compose(
-  material: Material,
-  named: ReadonlySet<string>,
-  tokens: Readonly<Record<string, Token>>,
-  kinds: Readonly<Record<string, string>>,
-): Readonly<Record<string, Holds>> {
-  return {
-    ...composed(material.sets, named, tokens, material.id, kinds, BOUND),
-    ...playing(material, material.plays),
-  }
-}
-
-export function keyframesOf(
-  material: Material,
-  named: ReadonlySet<string>,
-  tokens: Readonly<Record<string, Token>>,
-  kinds: Readonly<Record<string, string>>,
-): readonly {
-  readonly id: string
-  readonly stops: readonly { readonly stop: string; readonly made: Readonly<Record<string, Holds>> }[]
-}[] {
-  return (material.keyframes ?? []).map((one) => ({
-    id: one.id,
-    stops: Object.keys(one.sets).map((stop) => ({
-      stop,
-      made: composed(one.sets[stop] ?? [], named, tokens, material.id, kinds, BOUND),
-    })),
-  }))
-}

package/dist/ui/materials/mat_bordered.ts

@@ -1,13 +0,0 @@
-import { material } from '../material.ts'
-
-export const BORDERED = material({
-  id: 'bordered',
-  sets: [
-    { property: 'background', is: 'colour-surface' },
-    { property: 'borderWidth', is: 'edge-thick' },
-    { property: 'borderStyle', is: 'line-solid' },
-    { property: 'borderColor', is: 'colour-ink' },
-    { property: 'boxShadow', is: 'shadow-hard' },
-    { property: 'color', is: 'colour-ink' },
-  ],
-} as const)

package/dist/ui/materials/mat_ceramic.ts

@@ -1,13 +0,0 @@
-import { material } from '../material.ts'
-
-export const CERAMIC = material({
-  id: 'ceramic',
-  sets: [
-    { property: 'backgroundImage', is: 'gradient-sheen' },
-    { property: 'borderWidth', is: 'edge-hair' },
-    { property: 'borderStyle', is: 'line-solid' },
-    { property: 'borderColor', is: 'colour-edge-ceramic' },
-    { property: 'boxShadow', is: 'shadow-2' },
-    { property: 'color', is: 'colour-ink' },
-  ],
-} as const)

package/dist/ui/materials/mat_clay.ts

@@ -1,13 +0,0 @@
-import { material } from '../material.ts'
-
-export const CLAY = material({
-  id: 'clay',
-  sets: [
-    { property: 'background', is: 'colour-surface' },
-    { property: 'borderWidth', is: 'edge-thin' },
-    { property: 'borderStyle', is: 'line-solid' },
-    { property: 'borderColor', is: 'colour-edge-clay' },
-    { property: 'boxShadow', is: 'shadow-2' },
-    { property: 'color', is: 'colour-ink' },
-  ],
-} as const)

package/dist/ui/materials/mat_elevated.ts

@@ -1,24 +0,0 @@
-import { material } from '../material.ts'
-
-export const ELEVATED = material({
-  id: 'elevated',
-  sets: [
-    { property: 'background', is: 'colour-surface' },
-    { property: 'boxShadow', is: 'shadow-2' },
-    { property: 'color', is: 'colour-ink' },
-  ],
-  states: [
-    {
-      when: ['hover'],
-      sets: [{ property: 'boxShadow', is: 'shadow-3' }],
-    },
-    {
-      when: ['active'],
-      sets: [{ property: 'boxShadow', is: 'shadow-1' }],
-    },
-    {
-      when: ['active', 'hover'],
-      sets: [{ property: 'boxShadow', is: 'shadow-1' }],
-    },
-  ],
-} as const)

package/dist/ui/materials/mat_flat.ts

@@ -1,34 +0,0 @@
-import { material } from '../material.ts'
-
-export const FLAT = material({
-  id: 'flat',
-  sets: [
-    { property: 'background', is: 'colour-surface' },
-    { property: 'borderWidth', is: 'edge-hair' },
-    { property: 'borderStyle', is: 'line-solid' },
-    { property: 'borderColor', is: 'colour-edge-faint' },
-    { property: 'boxShadow', is: 'shadow-1' },
-    { property: 'color', is: 'colour-ink' },
-  ],
-  states: [
-    {
-      when: ['hover'],
-      sets: [{ property: 'boxShadow', is: 'shadow-2' }],
-    },
-    {
-      when: ['focus'],
-      sets: [
-        { property: 'borderColor', is: 'colour-accent' },
-        { property: 'borderWidth', is: 'edge-thick' },
-      ],
-    },
-    {
-      when: ['focus', 'hover'],
-      sets: [
-        { property: 'borderColor', is: 'colour-accent' },
-        { property: 'borderWidth', is: 'edge-thick' },
-        { property: 'boxShadow', is: 'shadow-2' },
-      ],
-    },
-  ],
-} as const)

package/dist/ui/materials/mat_glass.ts

@@ -1,20 +0,0 @@
-import { material } from '../material.ts'
-
-export const GLASS = material({
-  id: 'glass',
-  sets: [
-    { property: 'background', is: 'colour-glass' },
-    { property: 'backdropFilter', is: 'blur-md' },
-    { property: 'borderWidth', is: 'edge-hair' },
-    { property: 'borderStyle', is: 'line-solid' },
-    { property: 'borderColor', is: 'colour-edge-glass' },
-    { property: 'boxShadow', is: 'shadow-3' },
-    { property: 'color', is: 'colour-ink' },
-  ],
-  states: [
-    {
-      when: ['hover'],
-      sets: [{ property: 'backdropFilter', is: 'blur-lg' }],
-    },
-  ],
-} as const)

package/dist/ui/materials/mat_lit.ts

@@ -1,13 +0,0 @@
-import { material } from '../material.ts'
-
-export const LIT = material({
-  id: 'lit',
-  sets: [
-    { property: 'background', is: 'colour-surface-lit' },
-    { property: 'borderWidth', is: 'edge-thin' },
-    { property: 'borderStyle', is: 'line-solid' },
-    { property: 'borderColor', is: 'colour-edge-lit' },
-    { property: 'boxShadow', is: 'shadow-glow' },
-    { property: 'color', is: 'colour-ink' },
-  ],
-} as const)

package/dist/ui/materials/mat_moulded.ts

@@ -1,11 +0,0 @@
-import { material } from '../material.ts'
-
-export const MOULDED = material({
-  id: 'moulded',
-  sets: [
-    { property: 'background', is: 'colour-page' },
-    { property: 'borderStyle', is: 'line-off' },
-    { property: 'boxShadow', is: 'shadow-moulded' },
-    { property: 'color', is: 'colour-ink' },
-  ],
-} as const)

package/dist/ui/materials.ts

@@ -1,197 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from '@prestack/thread/integrations/disk'
-import { basename, join } from 'node:path'
-import { argv, stdout } from 'node:process'
-import { pathToFileURL } from 'node:url'
-
-import { exit, invoked } from '@prestack/thread/core/invoked'
-import type { Threaded } from '@prestack/thread/core/thread'
-import { findTree, inTree, strayFiles } from '@prestack/thread/core/tree'
-
-export const MATERIALS = {
-  id: 'material',
-  at: 'thread/ui/materials.ts',
-  files: 'ui/mat_*.ts',
-  describes:
-    'A combination of style guide values that gives one specific appearance, worn by any variant that names it: glass, clay, a glaze. It composes and never computes, because every value it sets is a name the style guide holds and never a raw one, which is what lets one material be worn by many variants. Each row names a file prefixed `mat_`, and that file is the material; a file under it that no row names is not a material but a file somebody wrote. An app adds its own to this same list, and a row that goes missing breaks the build, because what the framework offers is not an app’s to withdraw. These are materials and not aesthetics: Neumorphism, Claymorphism and Cyberpunk are templates, and a template is what picks a material.',
-  version: 1,
-  cites: [
-    {
-      on: '2026-08-25',
-      said: 'Style guides they can be used for simple pickings that need no thinking. We can pick colours and basic effects for using the app. Materials however are for more complex and detailed work. Materials.ts is a declaration sheet, SSOT, and each row is a file, mat_',
-    },
-  ],
-  declares: [
-    { id: 'glass', at: 'thread/ui/materials/mat_glass.ts', describes: 'A pane you can see through, with what is behind it softened and desaturation corrected for.' },
-    { id: 'flat', at: 'thread/ui/materials/mat_flat.ts', describes: 'Paper. A plain filled panel with a hairline and almost no lift — the same tokens as glass, asked more quietly.' },
-    { id: 'elevated', at: 'thread/ui/materials/mat_elevated.ts', describes: 'Something lifted off the page, reading by its shadow rather than by any outline.' },
-    { id: 'bordered', at: 'thread/ui/materials/mat_bordered.ts', describes: 'Ink on paper — a hard outline and a shadow with no blur, offset like a stamp.' },
-    { id: 'moulded', at: 'thread/ui/materials/mat_moulded.ts', describes: 'Pressed out of the page rather than laid on it. Its fill is the page itself, and its relief is one shadow cast twice in opposite directions.' },
-    { id: 'clay', at: 'thread/ui/materials/mat_clay.ts', describes: 'Something soft and inflated, lit from above — an outer shadow it sits in and an inset highlight along its top edge.' },
-    { id: 'lit', at: 'thread/ui/materials/mat_lit.ts', describes: 'Something that emits rather than reflects. Its glow is a shadow cast from nowhere in particular, and it names no colour of its own.' },
-    { id: 'ceramic', at: 'thread/ui/materials/mat_ceramic.ts', describes: 'A glazed surface with the light falling down its face. The one material that asks for a gradient rather than a fill.' },
-  ],
-} as const satisfies Threaded & { readonly files: string }
-
-export function nameOf(id: string): string {
-  return id.replace(/-/g, '_').toUpperCase()
-}
-
-function starter(row: Threaded): string {
-  const name = nameOf(row.id)
-  return `import { material } from './material.ts'
-
-export const ${name} = material({
-  id: '${row.id}',
-  sets: [],
-} as const)
-`
-}
-
-export function seeds(rows: readonly Threaded[], held: (at: string) => boolean): readonly { readonly path: string; readonly content: string }[] {
-  return rows.filter((row) => !held(row.at)).map((row) => ({ path: row.at, content: starter(row) }))
-}
-
-export async function mismatched(
-  rows: readonly Threaded[],
-  loader: (row: Threaded) => Promise<{ readonly id?: string } | undefined>,
-): Promise<readonly string[]> {
-  const found: string[] = []
-  for (const row of rows) {
-    const material = await loader(row)
-    if (material === undefined) {
-      found.push(
-        `\`${row.id}\` is declared at \`${row.at}\`, and that file exports no \`${nameOf(row.id)}\`. ` +
-          'A row names a file, and the file is the thing.',
-      )
-      continue
-    }
-    if (material.id !== row.id) {
-      found.push(
-        `\`${row.at}\` declares itself \`${String(material.id)}\`, and the row that names it calls it \`${row.id}\`. ` +
-          "A material file and the row that names it have to be the same material — make the file's `id` match the row, or fix the row.",
-      )
-    }
-  }
-  return found
-}
-
-export function orphaned(rows: readonly Threaded[], strays: readonly string[]): readonly string[] {
-  const named = new Set(rows.map((row) => row.at))
-  return strays
-    .filter((one) => !named.has(one))
-    .map(
-      (one) =>
-        `\`${one}\` is under materials and no row names it — not a material, a file somebody wrote. ` +
-        'Add a row for it, or delete the file.',
-    )
-}
-
-const GUARDED = /=\s*material\s*\(/
-
-const TYPED = /import type \{ Material \} from '([^']*)'/
-
-const OPENS = /export const ([A-Z0-9_]+) = \{/
-
-const CLOSES = /\} as const satisfies Material/
-
-export function unguarded(rows: readonly Threaded[], read: (at: string) => string): readonly string[] {
-  return rows
-    .filter((row) => !GUARDED.test(read(row.at)))
-    .map(
-      (row) =>
-        `\`${row.at}\` declares \`${row.id}\` with \`satisfies Material\`, which accepts a value no ` +
-        'row holds — `satisfies` checks against `string`, so `8px` and `var(--x)` compile. Run ' +
-        '`thread materials` and it rewrites the two lines that wrap the declaration, leaving what is ' +
-        'between them alone.',
-    )
-}
-
-export function guarding(source: string): string | undefined {
-  if (GUARDED.test(source)) return undefined
-  const typed = TYPED.exec(source)
-  const opens = OPENS.exec(source)
-  if (typed === null || opens === null || !CLOSES.test(source)) return undefined
-  return source
-    .replace(typed[0], `import { material } from '${typed[1] ?? ''}'`)
-    .replace(opens[0], `export const ${opens[1] ?? ''} = material({`)
-    .replace(CLOSES, '} as const)')
-}
-
-async function run(): Promise<number> {
-  const tree = findTree()
-  const at = inTree(tree, 'materials.ts')
-  if (!existsSync(at)) {
-    stdout.write(`thread: this tree has no ${tree.name}/${basename(at)}, so it declares no material and there is nothing to seed or check.\n`)
-    return 0
-  }
-  const held = (await import(pathToFileURL(at).href)) as { MATERIAL?: { readonly declares?: readonly Threaded[] } }
-
-  if (held.MATERIAL === undefined) {
-    stdout.write(`thread: ${tree.name}/materials.ts exports no \`MATERIAL\`, so nothing declares a material here.\n`)
-    return 1
-  }
-
-  const rows = held.MATERIAL.declares ?? []
-  const checking = argv.includes('--check')
-  const exists = (where: string): boolean => existsSync(join(tree.at, where))
-  const made = seeds(rows, exists)
-
-  if (checking) {
-    const unseeded = rows.find((row) => !exists(row.at))
-    if (unseeded !== undefined) {
-      stdout.write(
-        `thread: \`${unseeded.id}\` is declared at \`${unseeded.at}\`, and the file is not there yet. ` +
-          'A row names a file, and `--check` never writes one — run `thread materials` and commit what it seeds.\n',
-      )
-      return 1
-    }
-  } else {
-    for (const one of made) {
-      writeFileSync(join(tree.at, one.path), one.content, 'utf8')
-      stdout.write(`thread: seeded ${one.path}\n`)
-    }
-  }
-
-  const wrong = (
-    await mismatched(rows, async (row) => {
-      const module = (await import(pathToFileURL(join(tree.at, row.at)).href)) as Record<string, unknown>
-      return module[nameOf(row.id)] as { readonly id?: string } | undefined
-    })
-  )[0]
-  if (wrong !== undefined) {
-    stdout.write(`thread: ${wrong}\n`)
-    return 1
-  }
-
-  const read = (at: string): string => readFileSync(join(tree.at, at), 'utf8')
-  if (checking) {
-    const loose = unguarded(rows, read)[0]
-    if (loose !== undefined) {
-      stdout.write(`thread: ${loose}\n`)
-      return 1
-    }
-  } else {
-    for (const row of rows) {
-      const written = guarding(read(row.at))
-      if (written === undefined) continue
-      writeFileSync(join(tree.at, row.at), written, 'utf8')
-      stdout.write(`thread: ${row.at} now declares through \`material(...)\`\n`)
-    }
-  }
-
-  const stray = orphaned(rows, strayFiles(tree.at, 'mat_', '.' + 'ts'))[0]
-  if (stray !== undefined) {
-    stdout.write(`thread: ${stray}\n`)
-    return 1
-  }
-
-  stdout.write(
-    checking
-      ? `thread: ${String(rows.length)} material(s) declared, all seeded\n`
-      : `thread: ${String(rows.length)} material(s) declared, ${String(made.length)} seeded, ` +
-        `${String(rows.length - made.length)} already written\n`,
-  )
-  return 0
-}
-
-if (invoked(import.meta.url)) exit(await run())

package/dist/ui/modes.ts

@@ -1,44 +0,0 @@
-import type { Threaded } from '@prestack/thread/core/thread'
-
-const here = 'thread/ui/modes.ts'
-
-const said = [
-  {
-    on: '2026-08-25',
-    said: 'themes can have dark and light modes too. So they are not at all the same.',
-  },
-]
-
-const one = <Id extends string>(
-  id: Id,
-  is: string,
-  describes: string,
-): Omit<Threaded, 'at'> & { readonly id: Id; readonly is: string } => ({
-  id,
-  is,
-  describes,
-  version: 1,
-})
-
-export const holds = [
-  one(
-    'dark',
-    '(prefers-color-scheme: dark)',
-    'The reader has asked their device for a dark interface. Nothing about the app chooses this and nothing about the app can override it.',
-  ),
-  one(
-    'light',
-    '(prefers-color-scheme: light)',
-    'The reader has asked their device for a light interface. Stated rather than assumed, because the resting values are not the same thing as an answer to the question.',
-  ),
-] as const satisfies readonly (Omit<Threaded, 'at'> & { readonly is: string })[]
-
-export const MODES = {
-  id: 'mode',
-  at: here,
-  describes:
-    'Every way a reader’s own device can ask for a different look, and the query that answers it. A mode is chosen for the app rather than by it, which is what tells it from a theme — and a theme has its own modes, so the two are dimensions rather than one list. A mode changes what the variables hold, never what a material or a variant says.',
-  version: 1,
-  cites: said,
-  holds,
-} as const satisfies Threaded & { readonly holds: readonly (Omit<Threaded, 'at'> & { readonly is: string })[] }

package/dist/ui/navigation.tsx

@@ -1,29 +0,0 @@
-'use client'
-
-import type { MapIsland, Screen } from './islands/map.ts'
-
-export type ScreenName = Screen['id']
-
-export function trailTo(map: MapIsland, to: ScreenName): readonly ScreenName[] {
-  const entries = map.screens.filter((s) => s.entry).map((s) => s.id)
-  if (entries.includes(to)) return [to]
-
-  const seen = new Set<ScreenName>(entries)
-  let frontier: readonly (readonly ScreenName[])[] = entries.map((id) => [id])
-
-  while (frontier.length > 0) {
-    const next: (readonly ScreenName[])[] = []
-    for (const path of frontier) {
-      const here = path[path.length - 1] as ScreenName
-      for (const link of map.links.filter((l) => l.from === here)) {
-        if (link.to === to) return [...path, link.to]
-        if (seen.has(link.to)) continue
-        seen.add(link.to)
-        next.push([...path, link.to])
-      }
-    }
-    frontier = next
-  }
-  return []
-}
-