@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/slopnators/sl_undeclared_crossing.ts

@@ -1,87 +1,471 @@
-import { descend, under } from '../../core/descend.ts'
-
-import type { Slopnator } from '../slopnator.ts'
-import { here } from './sl_unthreaded.ts'
-
-interface Crossing {
-  readonly what: string
-  readonly finds: RegExp
-}
-
-const CROSSINGS: readonly Crossing[] = [
-  { what: 'the network', finds: /(?<![.\w])fetch\s*\(/ },
-  { what: 'the network', finds: /(?<![.\w])XMLHttpRequest\b/ },
-  { what: 'the clock', finds: /\bDate\s*\.\s*now\s*\(/ },
-  { what: 'the clock', finds: /\bperformance\s*\.\s*now\s*\(/ },
-  { what: 'the clock', finds: /\bsetInterval\s*\(/ },
-  { what: 'the clock', finds: /\bsetTimeout\s*\(/ },
-  { what: 'the clock', finds: /\brequestAnimationFrame\s*\(/ },
-  { what: 'randomness', finds: /\bMath\s*\.\s*random\s*\(/ },
-  { what: 'randomness', finds: /\bcrypto\s*\.\s*randomUUID\s*\(/ },
-  { what: 'the queue', finds: /\bqueue\s*\.\s*enqueue\s*\(/ },
-  { what: 'a seam', finds: /\b(?:files|llm|http)\s*\.\s*(?:call|run|complete|put|signedUrl|remove|get)\s*\(/ },
-]
-
-const OPERATIONS_ID = 'operations'
-
-const NODES_ID = 'nodes'
-
-let bodies: ReadonlySet<string> | undefined
-
-/*
- * The files this law is about, read off the tree rather than off a path.
- *
- * A crossing belongs in a declared node and nowhere else, so what the law has to know is which
- * files ARE declared nodes — every row in an operation's `seeds` that requires a node type. It
- * cannot be a path rule: an operation seeds its node bodies and its input file into the same
- * directory, so excepting the directory would except the input file too and leave a hole exactly
- * one file wide per operation. Measured 2026-08-27: with the directory excepted instead, this law
- * fired on `operations/wf_asks/asks_it.ts` — a node body calling the model its operation had
- * declared, which is the one place the law's own `instead` sends you.
- */
-function declared(): ReadonlySet<string> {
-  if (bodies !== undefined) return bodies
+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 OPENED_AT = fileURLToPath(new URL(FROM_SOURCE ? '../../operations/operations.ts' : '../../operations/operations.d.ts', import.meta.url))
+
+
+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()
-  const found = new Set<string>()
+  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([OPENED_AT, ...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()
+      return !program.isSourceFileDefaultLibrary(from) && !program.isSourceFileFromExternalLibrary(from)
+    })
+  const shape = program.getSourceFile(OPENED_AT)
+  for (const statement of shape?.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 (one.list !== 'seeds') continue
-      if (!under(pass, one.by, OPERATIONS_ID) || under(pass, one.by, NODES_ID)) continue
-      if ((one.row.requires ?? []).length === 0) continue
-      found.add(at)
+      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)
     }
   }
-  bodies = found
+  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 slopnator: Slopnator = {
-  holds: (_node, at) => {
-    if (declared().has(here(at.filename))) return false
-    for (const crossing of CROSSINGS) {
-      if (!crossing.finds.test(at.text)) continue
-      return (
-        `${crossing.what} reached outside a declared node — nothing recorded this crossing, so it ` +
-        'cannot be replayed, retried, priced or unwound, and the page renders exactly the same either way'
-      )
+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 && resolve(ROOT, path) === OPENED_AT) {
+    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: [
-      "const res = await fetch('https://api.stripe.com/v1/charges')",
-      'const at = Date.now()',
-      'const id = crypto.randomUUID()',
-      "await queue.enqueue('job', payload)",
-      "await files.put('receipt.pdf', bytes)",
-      'const t = setInterval(() => refetch(), 5000)',
-      'const t = setTimeout(function again() { refetch(); setTimeout(again, 5000) }, 5000)',
-      'window.requestAnimationFrame(step)',
+      "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: [
-      "const node = { id: 'st_charge', kind: 'action', action: 'payment.charge', declares: { seams: ['http'] } }",
-      'const rows = useRead(recentOrders)',
-      "const { data } = useRead(recentOrders, { refresh: 'every-5s' })",
+      '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.js

@@ -1,7 +1,6 @@
+import { descend, read, reached } from '../../core/descend.js';
+import { rowsIn } from './sl_unthreaded.js';
 const HREF = 'href';
-const GLOBALS = new Set(['window', 'globalThis', 'self']);
-const HISTORIES = new Set(['router', 'navigation', 'history']);
-const MOVES = new Set(['push', 'replace', 'prefetch']);
 const named = (held) => {
     if (held?.type === 'Identifier' || held?.type === 'JSXIdentifier')
         return typeof held.name === 'string' ? held.name : undefined;
@@ -16,41 +15,76 @@ const spoken = (held) => {
         return held.computed === true ? undefined : named(held.key);
     return undefined;
 };
-function moving(held) {
-    if (held.type !== 'MemberExpression' || held.computed === true)
-        return undefined;
-    const on = named(held.object);
-    const reached = named(held.property);
-    if (on === undefined || reached === undefined)
-        return undefined;
-    if (GLOBALS.has(on) && reached === 'location')
-        return `${on}.location`;
-    if (HISTORIES.has(on) && MOVES.has(reached))
-        return `${on}.${reached}()`;
-    return undefined;
+const SCREEN = 'screen';
+const PASCAL = (id) => id
+    .split(/[-_]/)
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join('');
+const nameOf = (at) => PASCAL((at.split('\\').join('/').split('/').at(-1) ?? at).replace(/^scr_/, '').replace(/\.[^.]+$/, ''));
+const routeFor = (id) => `/${id}`;
+function addressed() {
+    const found = new Map();
+    descend();
+    for (const at of reached()) {
+        const text = read(at);
+        if (text === undefined)
+            continue;
+        let waiting = [];
+        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 = {
-    on: ['JSXAttribute', 'Property', 'MemberExpression'],
+    on: ['JSXAttribute', 'Property', 'Literal'],
     holds: (node) => {
         const held = node;
-        const written = spoken(held) === HREF ? '`href`' : moving(held);
-        if (written === undefined)
+        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 (`${written} 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');
+        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' }",
-            "window.location = '/orders/42'",
-            "router.push('/orders/42')",
-            'history.replace(next)',
-            'navigation.prefetch(next)',
+            '<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: [
-            '<Link.label navigateTo="Home" labelKey="home.title" />',
+            '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'",
         ],
     },
 };