@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/slopnators/sl_undeclared_crossing.ts

@@ -1,481 +0,0 @@
-import { resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import ts from 'typescript'
-
-import { ROOT, THREAD_AT, configured, descend, hosting, sources, under, type Pass } from '../../core/descend.ts'
-import { packageOf } from '../../core/attach.ts'
-import { PREFIXES } from '../../core/thread.ts'
-import { HOLDS, OPENS, type Reach } from '../../integrations/target.ts'
-
-import type { Slopnator, SlopnatorContext } from '../slopnator.ts'
-
-const FROM_SOURCE = import.meta.url.endsWith('.ts')
-
-const SHAPE = 'operations/operations'
-
-const OPENED_AT = fileURLToPath(new URL('../../' + SHAPE + (FROM_SOURCE ? '.ts' : '.d.ts'), import.meta.url))
-
-const FRAMEWORK_AT = fileURLToPath(new URL('../../', import.meta.url))
-
-const FRAMEWORK = 'thread'
-
-const STATED_AT = resolve(ROOT, FRAMEWORK, SHAPE + '.ts')
-
-const SHAPES = [...new Set([STATED_AT, OPENED_AT])]
-
-
-const HANDED = 'Opened'
-
-const EVERY = ''
-
-const IMPORTED = 'import '
-
-const MADE = 'new '
-
-const ANYWHERE = 'globalThis'
-
-const REQUIRED = 'require'
-
-const RUNTIME = 'node:'
-
-const SOURCE = /[.](?:ts|tsx|mts|cts)$/
-
-const ROOTED = ROOT + '/'
-
-const here = (filename: string): string => (filename.startsWith(ROOTED) ? filename.slice(ROOTED.length) : filename)
-
-const plain = (specifier: string): string => (specifier.startsWith(RUNTIME) ? specifier.slice(RUNTIME.length) : specifier)
-
-interface Door {
-  readonly hand: string
-  readonly spelling: string
-}
-
-const HANDS: Readonly<Record<string, string>> = Object.fromEntries(
-  (Object.keys(HOLDS) as Reach[]).map((one) => [
-    one,
-    HOLDS[one].takes === 'entities' ? 'store' : HOLDS[one].takes === 'calls' ? 'target' : one,
-  ]),
-)
-
-function opening(): Readonly<Record<string, readonly string[]>> {
-  const found: Record<string, string[]> = {}
-  const add = (hand: string, spellings: readonly string[]): void => {
-    found[hand] = [...(found[hand] ?? []), ...spellings]
-  }
-  for (const [reach, spellings] of Object.entries(OPENS)) add(HANDS[reach] ?? reach, spellings)
-  return found
-}
-
-interface Doors {
-  readonly modules: ReadonlyMap<string, Door>
-  readonly members: ReadonlyMap<string, ReadonlyMap<string, Door>>
-  readonly globals: ReadonlyMap<string, Door>
-  readonly properties: ReadonlyMap<string, Door>
-  readonly made: ReadonlyMap<string, Door>
-}
-
-function doors(): Doors {
-  const modules = new Map<string, Door>()
-  const members = new Map<string, Map<string, Door>>()
-  const globals = new Map<string, Door>()
-  const properties = new Map<string, Door>()
-  const made = new Map<string, Door>()
-  for (const [hand, spellings] of Object.entries(opening())) {
-    for (const spelling of spellings) {
-      const door = { hand, spelling }
-      if (spelling.startsWith(IMPORTED)) {
-        const rest = spelling.slice(IMPORTED.length)
-        const dot = rest.lastIndexOf('.')
-        if (dot === -1 || rest.slice(dot).includes('/')) {
-          modules.set(plain(rest), door)
-          continue
-        }
-        const specifier = plain(rest.slice(0, dot))
-        const held = members.get(specifier) ?? new Map<string, Door>()
-        held.set(rest.slice(dot + 1), door)
-        members.set(specifier, held)
-        continue
-      }
-      if (spelling.startsWith(MADE)) {
-        made.set(spelling.slice(MADE.length), door)
-        continue
-      }
-      if (spelling.includes('.')) properties.set(spelling, door)
-      else globals.set(spelling, door)
-    }
-  }
-  return { modules, members, globals, properties, made }
-}
-
-const DOORS = doors()
-
-const INTEGRATION = 'Integration'
-
-const NEEDS = 'needs'
-
-function needed(pass: Pass): ReadonlyMap<string, Door> {
-  const found = new Map<string, Door>()
-  const rows = [...pass.stated.values(), ...[...pass.threaded.values()].flat().map((one) => one.row)]
-  for (const row of rows) {
-    if (row.type !== INTEGRATION) continue
-    const held = row.fields.get(NEEDS)
-    if (held === undefined || !ts.isObjectLiteralExpression(held)) continue
-    for (const one of held.properties) {
-      if (!ts.isPropertyAssignment(one)) continue
-      const name = ts.isStringLiteral(one.name) || ts.isIdentifier(one.name) ? one.name.text : undefined
-      if (name !== undefined) found.set(name, { hand: HANDS['sdk'] ?? 'sdk', spelling: IMPORTED + name })
-    }
-  }
-  return found
-}
-
-const moduleOf = (door: Door): string => door.spelling.slice(IMPORTED.length, door.spelling.lastIndexOf('.'))
-
-const stands = (door: Door): string => ', which the ' + door.hand + ' this app is handed stands in for'
-
-interface Built {
-  readonly of: Pass
-  readonly program: ts.Program
-  readonly checker: ts.TypeChecker
-  readonly hands: ReadonlyMap<ts.Symbol, string>
-  readonly packages: ReadonlyMap<string, Door>
-}
-
-let built: Built | undefined
-
-function argumentsOf(type: ts.Type, checker: ts.TypeChecker): readonly ts.Type[] {
-  const found: ts.Type[] = [...(type.aliasTypeArguments ?? [])]
-  if ((type.flags & ts.TypeFlags.Object) !== 0 && ((type as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference) !== 0) {
-    found.push(...checker.getTypeArguments(type as ts.TypeReference))
-  }
-  return found
-}
-
-function handed(type: ts.Type, checker: ts.TypeChecker, hand: string, into: Map<ts.Symbol, string>, seen: Set<ts.Type>, own: (symbol: ts.Symbol) => boolean): void {
-  if (seen.has(type)) return
-  seen.add(type)
-  if (type.isUnionOrIntersection()) {
-    for (const one of type.types) handed(one, checker, hand, into, seen, own)
-    return
-  }
-  for (const one of argumentsOf(type, checker)) handed(one, checker, hand, into, seen, own)
-  const index = checker.getIndexTypeOfType(type, ts.IndexKind.String)
-  if (index !== undefined) handed(index, checker, hand, into, seen, own)
-  const symbol = type.getSymbol()
-  if (symbol === undefined || !own(symbol)) return
-  if ((symbol.flags & (ts.SymbolFlags.Interface | ts.SymbolFlags.TypeLiteral | ts.SymbolFlags.Class)) === 0) return
-  if (!into.has(symbol)) into.set(symbol, hand)
-}
-function given(node: ts.TypeNode, checker: ts.TypeChecker, into: Map<ts.Symbol, string>, own: (symbol: ts.Symbol) => boolean): void {
-  const take = (one: ts.Node): void => {
-    if (ts.isTypeReferenceNode(one)) {
-      const named = ts.isIdentifier(one.typeName) ? one.typeName : one.typeName.right
-      const found = checker.getSymbolAtLocation(named)
-      const real = found !== undefined && (found.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(found) : found
-      const shapes = ts.SymbolFlags.Interface | ts.SymbolFlags.Class | ts.SymbolFlags.TypeAlias
-      if (real !== undefined && own(real) && (real.flags & shapes) !== 0 && !into.has(real)) into.set(real, EVERY)
-    }
-    ts.forEachChild(one, take)
-  }
-  const inside = (one: ts.Node): void => {
-    if (ts.isMappedTypeNode(one)) {
-      if (one.type !== undefined) take(one.type)
-      return
-    }
-    ts.forEachChild(one, inside)
-  }
-  inside(node)
-}
-
-function compiled(): Built {
-  const pass = descend()
-  if (built !== undefined && built.of === pass) return built
-  const options = configured().options
-  const roots = [THREAD_AT, ...sources()].filter((one) => SOURCE.test(one)).map((one) => resolve(ROOT, one))
-  const program = ts.createProgram([...new Set([...SHAPES, ...roots])], options, hosting(options))
-  const checker = program.getTypeChecker()
-  const hands = new Map<ts.Symbol, string>()
-  const own = (symbol: ts.Symbol): boolean =>
-    (symbol.getDeclarations() ?? []).some((one) => {
-      const from = one.getSourceFile()
-      if (from.fileName.startsWith(FRAMEWORK_AT)) return true
-      return !program.isSourceFileDefaultLibrary(from) && !program.isSourceFileFromExternalLibrary(from)
-    })
-  for (const statement of SHAPES.flatMap((one) => program.getSourceFile(one)?.statements ?? [])) {
-    if (!ts.isTypeAliasDeclaration(statement) || statement.name.text !== HANDED) continue
-    const alias = checker.getSymbolAtLocation(statement.name)
-    if (alias !== undefined) hands.set(alias, EVERY)
-    handed(checker.getTypeFromTypeNode(statement.type), checker, EVERY, hands, new Set(), own)
-    given(statement.type, checker, hands, own)
-  }
-  built = { of: pass, program, checker, hands, packages: needed(pass) }
-  return built
-}
-
-const INTEGRATIONS_ID = 'integrations'
-
-function integral(pass: Pass, path: string): boolean {
-  for (const [at, threadings] of pass.threaded) {
-    if (at !== path) continue
-    for (const one of threadings) {
-      if (one.by === INTEGRATIONS_ID || under(pass, one.by, INTEGRATIONS_ID)) return true
-    }
-  }
-  return false
-}
-
-function operational(pass: Pass, path: string): boolean {
-  const prefixes = Object.values(PREFIXES)
-  const owned = (one: string): boolean => prefixes.some((prefix) => one.startsWith(prefix))
-  if (path.split('/').some((part) => owned(part))) return true
-  for (const [at, threadings] of pass.threaded) {
-    if (at !== path) continue
-    for (const one of threadings) {
-      if (owned(one.by) || owned(String(one.row.id ?? ''))) return true
-    }
-  }
-  return false
-}
-
-function handOf(type: ts.Type, checker: ts.TypeChecker, hands: ReadonlyMap<ts.Symbol, string>, seen: Set<ts.Type>): string | undefined {
-  if (seen.has(type)) return undefined
-  seen.add(type)
-  const named = type.aliasSymbol === undefined ? undefined : hands.get(type.aliasSymbol)
-  if (named !== undefined) return named
-  if (type.isUnionOrIntersection()) {
-    for (const one of type.types) {
-      const found = handOf(one, checker, hands, seen)
-      if (found !== undefined) return found
-    }
-    return undefined
-  }
-  const symbol = type.getSymbol() ?? type.aliasSymbol
-  const own = symbol === undefined ? undefined : hands.get(symbol)
-  if (own !== undefined) return own
-  for (const one of argumentsOf(type, checker)) {
-    const found = handOf(one, checker, hands, seen)
-    if (found !== undefined) return found
-  }
-  return undefined
-}
-
-function implemented(file: ts.SourceFile, built: Built): ReadonlySet<string> {
-  const found = new Set<string>()
-  const { checker, hands } = built
-  const held = checker.getSymbolAtLocation(file)
-  if (held === undefined) return found
-  const carries = (type: ts.Type, depth: number, seen: Set<ts.Type>): void => {
-    if (seen.has(type)) return
-    seen.add(type)
-    const hand = handOf(type, checker, hands, new Set())
-    if (hand !== undefined) found.add(hand)
-    if (depth === 0) return
-    for (const one of type.isUnionOrIntersection() ? type.types : [type]) {
-      for (const signature of one.getCallSignatures()) carries(signature.getReturnType(), depth - 1, seen)
-      for (const property of one.getProperties()) carries(checker.getTypeOfSymbolAtLocation(property, file), depth - 1, seen)
-    }
-  }
-  for (const exported of checker.getExportsOfModule(held)) {
-    const real = (exported.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(exported) : exported
-    if ((real.flags & ts.SymbolFlags.Value) === 0) continue
-    carries(checker.getTypeOfSymbolAtLocation(real, file), 2, new Set())
-  }
-  return found
-}
-
-export const DOORWAY = 'door'
-
-export const HANDED_TO = 'hand'
-
-interface Noted {
-  readonly line: number
-  readonly said: string
-  readonly kind: string
-}
-
-function judged(path: string, built: Built, operates: boolean, wanted: string): readonly string[] {
-  const file = built.program.getSourceFile(resolve(ROOT, path))
-  if (file === undefined) return []
-  const { checker, hands } = built
-  let door: boolean | undefined
-  let allowed: ReadonlySet<string> | undefined
-  const may = (hand: string): boolean => {
-    if (door === undefined) door = integral(built.of, path)
-    if (allowed === undefined) allowed = implemented(file, built)
-    return allowed.has(EVERY) || allowed.has(hand) || door || (operates && hand === EVERY)
-  }
-  const found: Noted[] = []
-  const line = (node: ts.Node): number => file.getLineAndCharacterOfPosition(node.getStart(file)).line + 1
-  const note = (node: ts.Node, said: string, kind: string): void => {
-    found.push({ line: line(node), said: 'line ' + String(line(node)) + ': ' + said, kind })
-  }
-  const locals = new Map<string, Door>()
-  const spaces = new Map<string, ReadonlyMap<string, Door>>()
-
-  const global = (id: ts.Identifier): boolean => {
-    const symbol = checker.getSymbolAtLocation(id)
-    if (symbol === undefined) return true
-    const declared = symbol.getDeclarations() ?? []
-    return declared.every((one) => one.getSourceFile().isDeclarationFile)
-  }
-
-  const named = (node: ts.Node): boolean => {
-    const parent = node.parent as { readonly name?: ts.Node } | undefined
-    return parent !== undefined && parent.name === node
-  }
-
-  const inType = (node: ts.Node): boolean => {
-    let up: ts.Node | undefined = node
-    while (up !== undefined) {
-      if (ts.isTypeQueryNode(up)) return true
-      up = up.parent
-    }
-    return false
-  }
-
-  const reaching = (specifier: string, node: ts.Node): void => {
-    const door = DOORS.modules.get(plain(specifier)) ?? built.packages.get(packageOf(specifier))
-    if (door !== undefined && !may(door.hand)) note(node, 'imports ' + specifier + stands(door), DOORWAY)
-  }
-
-  const visit = (node: ts.Node): void => {
-    if (ts.isImportDeclaration(node) && node.importClause?.isTypeOnly !== true && ts.isStringLiteral(node.moduleSpecifier)) {
-      reaching(node.moduleSpecifier.text, node)
-      const held = DOORS.members.get(plain(node.moduleSpecifier.text))
-      const bindings = node.importClause?.namedBindings
-      if (held !== undefined && bindings !== undefined) {
-        if (ts.isNamespaceImport(bindings)) spaces.set(bindings.name.text, held)
-        else {
-          for (const element of bindings.elements) {
-            const door = held.get((element.propertyName ?? element.name).text)
-            if (door !== undefined) locals.set(element.name.text, door)
-          }
-        }
-      }
-    }
-    if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier)) {
-      reaching(node.moduleSpecifier.text, node)
-    }
-    if (ts.isCallExpression(node)) {
-      const first = node.arguments[0]
-      const loads = node.expression.kind === ts.SyntaxKind.ImportKeyword || (ts.isIdentifier(node.expression) && node.expression.text === REQUIRED)
-      if (loads && first !== undefined && ts.isStringLiteral(first)) reaching(first.text, node)
-      const callee = node.expression
-      if (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee)) {
-        const taken = callee.expression
-        const hand =
-          handOf(checker.getTypeAtLocation(taken), checker, hands, new Set()) ??
-          (ts.isPropertyAccessExpression(taken) || ts.isElementAccessExpression(taken)
-            ? handOf(checker.getTypeAtLocation(taken.expression), checker, hands, new Set())
-            : undefined)
-        if (hand !== undefined && !may(hand)) {
-          const what = ts.isPropertyAccessExpression(callee) ? callee.name.text : 'an order'
-          note(node, 'calls ' + what + ' on ' + (hand === EVERY ? 'what this app hands an operation' : 'the ' + hand + ' it is handed'), HANDED_TO)
-        }
-      }
-    }
-    if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && (node.arguments ?? []).length === 0) {
-      const door = DOORS.made.get(node.expression.text)
-      if (door !== undefined && !may(door.hand) && global(node.expression)) note(node, 'reaches ' + door.spelling + '()' + stands(door), DOORWAY)
-    }
-    if (ts.isPropertyAccessExpression(node) && !ts.isPartOfTypeNode(node)) {
-      const inner = ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === ANYWHERE ? node.expression.name : undefined
-      const object = inner ?? node.expression
-      if (ts.isIdentifier(object)) {
-        const spaced = spaces.get(object.text)?.get(node.name.text)
-        if (spaced !== undefined && !may(spaced.hand)) note(node, 'reaches ' + node.name.text + ' from ' + moduleOf(spaced) + stands(spaced), DOORWAY)
-        const door = DOORS.properties.get(object.text + '.' + node.name.text)
-        if (door !== undefined && !may(door.hand) && (inner !== undefined || global(object))) note(node, 'reaches ' + door.spelling + stands(door), DOORWAY)
-        if (object.text === ANYWHERE) {
-          const bare = DOORS.globals.get(node.name.text)
-          if (bare !== undefined && !may(bare.hand)) note(node, 'reaches ' + bare.spelling + stands(bare), DOORWAY)
-        }
-      }
-    }
-    if (ts.isIdentifier(node) && !named(node) && !ts.isPartOfTypeNode(node) && !inType(node)) {
-      const local = locals.get(node.text)
-      if (local !== undefined && !may(local.hand)) note(node, 'reaches ' + node.text + ' from ' + moduleOf(local) + stands(local), DOORWAY)
-      const door = DOORS.globals.get(node.text)
-      if (door !== undefined && !may(door.hand) && global(node)) note(node, 'reaches ' + door.spelling + stands(door), DOORWAY)
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(file)
-  return found.filter((one) => one.kind === wanted).sort((one, two) => one.line - two.line).map((one) => one.said)
-}
-
-export function judging(at: SlopnatorContext, wanted: string, closing: string): string | false {
-  const path = here(at.filename)
-  if (!SOURCE.test(path)) return false
-  const held = compiled()
-  if (held.hands.size === 0 && SHAPES.includes(resolve(ROOT, path))) {
-    return 'no type called ' + HANDED + ' can be read here, so nothing can tell what an operation was opened with from any other value, and a call on it outside an operation goes unmeasured'
-  }
-  const found = judged(path, held, operational(held.of, path), wanted)
-  if (found.length === 0) return false
-  return found.join('; ') + '. ' + closing
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) =>
-    judging(at, DOORWAY, 'Each of these reaches past this process without going through a declared integration, and a reach this app never declared is one nothing can price, replay or unwind.'),
-  proves: {
-    wrong: [
-      "import { spawnSync } from 'node:child_process'\n\nexport const ran = spawnSync('git', ['status'])",
-      "import * as processes from 'node:child_process'\n\nexport const ran = processes.spawnSync('git', ['status'])",
-      {
-        files: [
-          { at: 'threads/thread.ts', source: "export const THREAD: Threaded = {\n  declares: [\n    { id: 'wf_thing', at: 'operations/wf_thing.ts' },\n  ],\n}\n" },
-          { at: 'operations/wf_thing.ts', source: "export const asked = await fetch('https://example.com')" },
-        ],
-        at: 'operations/wf_thing.ts',
-      },
-      "import { PGlite } from '@electric-sql/pglite'\n\nexport const db = new PGlite()",
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: 'export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n}\n' },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport interface Integration extends Threaded {\n  readonly needs?: Readonly<Record<string, string>>\n}\n\nexport const THREAD: Threaded = {\n  declares: [\n    { id: 'wf_pad', at: 'operations/wf_pad.ts' },\n  ],\n}\n\nexport const INTEGRATIONS: readonly Integration[] = [\n  { id: 'in_pad', describes: 'Pads text.', needs: { 'left-pad': '^1.3.0' } },\n]\n" },
-          { at: 'operations/wf_pad.ts', source: "import pad from 'left-pad'\n\nexport const padded = pad('a', 3)\n" },
-        ],
-        at: 'operations/wf_pad.ts',
-      },
-    ],
-    right: [
-      'export const began = Date.now()',
-      'export const later = setTimeout(() => again(), 5000)',
-      "import { randomBytes } from 'node:crypto'\n\nexport const nonce = randomBytes(6).toString('hex')",
-      "import { join } from 'node:path'\n\nexport const at = join('a', 'b')",
-      "import { createHash } from 'node:crypto'\n\nexport const sum = createHash('sha256').update('a').digest('hex')",
-      'export const when = new Date(1767225600000)',
-      {
-        files: [
-          { at: 'thread/operations/operations.ts', source: 'export interface Http {\n  call(address: string): Promise<void>\n}\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Http }\n' },
-          { at: 'threads/_probe_door.ts', source: "import type { Http } from '../thread/operations/operations.ts'\n\nexport const made: Http = {\n  call: async (address) => {\n    await fetch(address)\n  },\n}\n" },
-        ],
-        at: 'threads/_probe_door.ts',
-      },
-      {
-        files: [
-          { at: 'thread/operations/operations.ts', source: 'export interface Store {\n  insert(row: unknown): Promise<void>\n}\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Store }\n' },
-          { at: 'threads/_probe_handed.ts', source: "import type { Opened } from '../thread/operations/operations.ts'\n\nexport const carried = (opened: Opened<'pg_main'>, run: (given: Opened<'pg_main'>) => Promise<void>): Promise<void> => run(opened)\n" },
-        ],
-        at: 'threads/_probe_handed.ts',
-      },
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: 'export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n}\n' },
-          { at: 'thread/operations/operations.ts', source: 'export type Calling = { readonly [call: string]: (given?: unknown) => Promise<unknown> }\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Calling }\n' },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport interface Integration extends Threaded {\n  readonly needs?: Readonly<Record<string, string>>\n}\n\nexport const THREAD: Threaded = {\n  declares: [\n    { id: 'sdk_pad_calls', at: 'src/sdk/sdk_pad.ts' },\n  ],\n}\n\nexport const INTEGRATIONS: readonly Integration[] = [\n  { id: 'in_pad', describes: 'Pads text.', needs: { 'left-pad': '^1.3.0' } },\n]\n" },
-          { at: 'src/sdk/sdk_pad.ts', source: "import type { Calling } from '../../thread/operations/operations.ts'\nimport pad from 'left-pad'\n\nexport const calls: Calling = {\n  padded: async (given) => pad(String(given), 3),\n}\n" },
-        ],
-        at: 'src/sdk/sdk_pad.ts',
-      },
-    ],
-  },
-}
-
-
-
-

package/dist/integrity/slopnators/sl_undeclared_destination.ts

@@ -1,113 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-
-import { descend, read, reached } from '../../core/descend.ts'
-import { rowsIn } from './sl_unthreaded.ts'
-
-interface Held {
-  readonly type?: string
-  readonly name?: unknown
-  readonly value?: unknown
-  readonly computed?: boolean
-  readonly object?: Held
-  readonly property?: Held
-  readonly key?: Held
-}
-
-const HREF = 'href'
-
-const named = (held: Held | undefined): string | undefined => {
-  if (held?.type === 'Identifier' || held?.type === 'JSXIdentifier') return typeof held.name === 'string' ? held.name : undefined
-  if (held?.type === 'Literal' && typeof held.value === 'string') return held.value
-  return undefined
-}
-
-const spoken = (held: Held): string | undefined => {
-  if (held.type === 'JSXAttribute') return named(held.name as Held | undefined)
-  if (held.type === 'Property') return held.computed === true ? undefined : named(held.key)
-  return undefined
-}
-
-const SCREEN = 'screen'
-
-const PASCAL = (id: string): string =>
-  id
-    .split(/[-_]/)
-    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
-    .join('')
-
-const nameOf = (at: string): string =>
-  PASCAL((at.split('\\').join('/').split('/').at(-1) ?? at).replace(/^scr_/, '').replace(/\.[^.]+$/, ''))
-
-const routeFor = (id: string): string => `/${id}`
-
-function addressed(): ReadonlyMap<string, string> {
-  const found = new Map<string, string>()
-
-  descend()
-
-  for (const at of reached()) {
-    const text = read(at)
-    if (text === undefined) continue
-
-    let waiting: { readonly id: string; readonly at: string }[] = []
-    for (const one of rowsIn(text)) {
-      if (one.id === undefined) continue
-      if (one.list === 'declares') {
-        if (one.at !== undefined) waiting.push({ id: one.id, at: one.at })
-        continue
-      }
-      if (one.list !== undefined) continue
-      if (one.id === SCREEN) for (const row of waiting) found.set(routeFor(row.id), nameOf(row.at))
-      waiting = []
-    }
-  }
-
-  return found
-}
-
-export const slopnator: Slopnator = {
-  on: ['JSXAttribute', 'Property', 'Literal'],
-  holds: (node) => {
-    const held = node as Held
-
-    if (spoken(held) === HREF) {
-      return (
-        '`href` moves somebody without naming a screen, so the map holds no link for it — ' +
-        'the destination reads as unreachable to the orphan pass, the app reads as having no path to it, and it navigates correctly'
-      )
-    }
-
-    if (held.type !== 'Literal' || typeof held.value !== 'string') return false
-
-    const screen = addressed().get(held.value)
-    if (screen === undefined) return false
-
-    return (
-      'this writes the address of ' + screen + ' rather than naming it, so the map holds no link for it — ' +
-      'the destination reads as unreachable to the orphan pass and the app navigates there anyway. Name the screen: navigateTo="' + screen + '"'
-    )
-  },
-  proves: {
-    wrong: [
-      "const link = { href: '/orders/42' }",
-      '<a href="/orders/42">{label}</a>',
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_probe_screens.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_probe_screens.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const SCREENS: Threaded = {\n  id: 'screen',\n  declares: [\n    {\n      id: 'orders',\n      at: 'screens/scr_orders.tsx',\n    },\n  ],\n}\n" },
-          { at: 'app/_probe_address.tsx', source: "export const HELD = router.push('/orders')\n" },
-        ],
-        at: 'app/_probe_address.tsx',
-      },
-    ],
-    right: [
-      'const path = router.pathname',
-      '<Link.linkInline navigateTo="Home" labelKey="home.title" />',
-      "const to = { navigateTo: 'Order', labelKey: 'order.title' }",
-      'const rows = orders.push(one)',
-      "const parts = one.split('/')",
-      "const at = '/api/webhook'",
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_undeclared_element.ts

@@ -1,44 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-
-interface Tag {
-  readonly type?: string
-  readonly name?: unknown
-  readonly namespace?: { readonly name?: unknown }
-}
-
-const HOST = /^[a-z]/
-
-function tagOf(node: unknown): string | undefined {
-  const name = (node as { name?: Tag } | undefined)?.name
-  if (name?.type === 'JSXNamespacedName') {
-    const space = typeof name.namespace?.name === 'string' ? name.namespace.name : ''
-    const local = typeof (name.name as Tag | undefined)?.name === 'string' ? String((name.name as Tag).name) : ''
-    return `${space}:${local}`
-  }
-  if (name?.type !== 'JSXIdentifier') return undefined
-  return typeof name.name === 'string' ? name.name : undefined
-}
-
-export const slopnator: Slopnator = {
-  on: ['JSXOpeningElement'],
-  holds: (node) => {
-    const tag = tagOf(node)
-    if (tag === undefined || !HOST.test(tag)) return false
-    return (
-      `<${tag}> is a host element, so it wears no declared style, sits in no catalogue, and the style guide, ` +
-      'a rebrand and every overlay read past it — it renders and nothing downstream knows it is there'
-    )
-  },
-  proves: {
-    wrong: [
-      '<div className="row" />',
-      '<button onClick={save}>save</button>',
-      '<svg:path d="M0 0" />',
-    ],
-    right: [
-      '<Box.card />',
-      '<Column>{rows}</Column>',
-      '<Button.buttonPrimary label="save" />',
-    ],
-  },
-}