@prestack/thread 0.0.1 → 0.0.2

package/dist/integrity/slopnators/sl_unprefixed_member.ts

@@ -0,0 +1,136 @@
+import { inCode, listBounds, matched } from '../../core/rows.ts'
+import { PREFIXES } from '../../core/thread.ts'
+
+import type { Slopnator } from '../slopnator.ts'
+import { here, parses, unreadable } from './sl_unthreaded.ts'
+
+const MEMBERS = 'MEMBERS'
+
+/*
+ * Which prefixes a tree file's member list may hold.
+ *
+ * The file is the key because the list is named the same in both: `MEMBERS` in the operations tree
+ * holds what an app can be asked to do, and `MEMBERS` in the nodes tree holds the spans an operation
+ * is built from. Nothing in TypeScript separates them — both are arrays of rows carrying a string id
+ * — so an operation declared among the nodes, or a node among the operations, typechecks, attaches,
+ * seeds a body and reads as agreed by everything downstream.
+ *
+ * What an operation may wear is not written here. `@thread/core/thread` pairs each word an
+ * operation can be with the prefix its id takes, and `thread create` puts that prefix on — so the
+ * command that makes them and the law that refuses them read one list. Written out again here,
+ * a kind added over there would be a kind this refuses.
+ */
+const TAKES: Readonly<Record<string, readonly string[]>> = {
+  'operations.ts': Object.values(PREFIXES),
+  'nodes.ts': ['nd_', 'sm_'],
+}
+
+const ID = /\bid:\s*'((?:[^'\\]|\\.)*)'/
+
+/*
+ * The id of every row sitting directly in the list, and no deeper.
+ *
+ * Depth is the whole of it: a member row states its own id, and the `seeds` and `derives` rows under
+ * it state theirs, which are neither operations nor nodes — `wf_send_invoice_body` is a body, not
+ * something an app can be asked to do. Reading every id in the list would refuse those children for
+ * lacking a prefix they were never meant to wear.
+ *
+ * The braces are read off `inCode`, not off the raw text. Counting characters directly desynced on a
+ * `describes:` holding a brace, and this package already ships the mask and the matcher for exactly
+ * that — a second, weaker walker beside them is the drift they exist to prevent.
+ */
+function directly(text: string, open: number, close: number): readonly string[] {
+  const code = inCode(text)
+  const found: string[] = []
+  for (let at = open; at < close; at += 1) {
+    if (code[at] !== true || text[at] !== '{') continue
+    const ends = matched(text, code, at, '{', '}')
+    if (ends === -1 || ends > close) break
+    const said = ID.exec(text.slice(at, ends))?.[1]
+    if (said !== undefined) found.push(said)
+    at = ends
+  }
+  return found
+}
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+    if (unreadable(path, at.text) !== undefined) return false
+    if (!parses(path)) return false
+
+    const takes = TAKES[path.slice(path.lastIndexOf('/') + 1)]
+    if (takes === undefined) return false
+
+    const text = String(at.text)
+    const where = listBounds(text, MEMBERS)
+    if (where === undefined) return false
+
+    for (const said of directly(text, where.open, where.close)) {
+      if (takes.some((one) => said.startsWith(one))) continue
+      return (
+        `\`${said}\` sits in \`${MEMBERS}\` here, and this list takes ${takes.map((one) => `\`${one}\``).join(', ')}. ` +
+        'A prefix is what says which of the two a row is, and a row wearing the wrong one is declared as ' +
+        'something it is not, seeds a body of the wrong shape, and is read as agreed by everything downstream'
+      )
+    }
+
+    return false
+  },
+  proves: {
+    wrong: [
+      {
+        files: [
+          {
+            at: '_threads/operations.ts',
+            source:
+              "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  at: '_threads/operations.ts',\n  describes: 'what an app can be asked to do',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'nd_teleport',\n    at: '_threads/operations.ts',\n    describes: 'a node wearing an operation list',\n    version: 1,\n  },\n]\n",
+          },
+        ],
+        at: '_threads/operations.ts',
+      },
+      {
+        files: [
+          {
+            at: '_threads/nodes.ts',
+            source:
+              "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const NODES: Threaded = {\n  id: 'nodes',\n  at: '_threads/nodes.ts',\n  describes: 'the spans an operation is built from',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'wf_send_invoice',\n    at: '_threads/nodes.ts',\n    describes: 'an operation wearing a node list',\n    version: 1,\n  },\n]\n",
+          },
+        ],
+        at: '_threads/nodes.ts',
+      },
+      {
+        files: [
+          {
+            at: '_threads/operations.ts',
+            source:
+              "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  at: '_threads/operations.ts',\n  describes: 'what an app can be asked to do',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'sendInvoice',\n    at: '_threads/operations.ts',\n    describes: 'no prefix at all',\n    version: 1,\n  },\n]\n",
+          },
+        ],
+        at: '_threads/operations.ts',
+      },
+    ],
+    right: [
+      {
+        files: [
+          {
+            at: '_threads/operations.ts',
+            source:
+              "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  at: '_threads/operations.ts',\n  describes: 'what an app can be asked to do',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'wf_send_invoice',\n    at: '_threads/operations.ts',\n    describes: 'sends an invoice',\n    version: 1,\n    seeds: [\n      {\n        id: 'wf_send_invoice_body',\n        at: 'operations/wf_send_invoice.ts',\n        describes: 'the operation itself',\n      },\n    ],\n  },\n]\n",
+          },
+        ],
+        at: '_threads/operations.ts',
+      },
+      {
+        files: [
+          {
+            at: '_threads/nodes.ts',
+            source:
+              "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const NODES: Threaded = {\n  id: 'nodes',\n  at: '_threads/nodes.ts',\n  describes: 'the spans an operation is built from',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'nd_teleport',\n    at: '_threads/nodes.ts',\n    describes: 'a step this app added',\n    version: 1,\n  },\n]\n",
+          },
+        ],
+        at: '_threads/nodes.ts',
+      },
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_unseamed_reach.ts

@@ -0,0 +1,79 @@
+import { isBuiltin } from 'node:module'
+
+import { parser } from 'typescript-eslint'
+
+import type { Slopnator } from '../slopnator.ts'
+
+const CODE = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/
+
+const MENTIONS = /\bimport\b|\brequire\s*\(/
+
+function reached(node: unknown, seen: WeakSet<object>, found: (one: string) => void): void {
+  if (typeof node !== 'object' || node === null) return
+  if (seen.has(node)) return
+  seen.add(node)
+
+  if (Array.isArray(node)) {
+    for (const each of node) reached(each, seen, found)
+    return
+  }
+
+  const one = node as Record<string, unknown>
+  const type = one['type']
+
+  if (type === 'ImportDeclaration' || type === 'ImportExpression' || type === 'ExportNamedDeclaration' || type === 'ExportAllDeclaration') {
+    const source = one['source'] as { readonly value?: unknown } | null | undefined
+    if (typeof source?.value === 'string') found(source.value)
+  }
+
+  if (type === 'CallExpression') {
+    const callee = one['callee'] as { readonly type?: unknown; readonly name?: unknown } | null | undefined
+    if (callee?.type === 'Identifier' && callee.name === 'require') {
+      const first = (one['arguments'] as readonly { readonly value?: unknown }[] | undefined)?.[0]
+      if (typeof first?.value === 'string') found(first.value)
+    }
+  }
+
+  for (const held of Object.values(one)) reached(held, seen, found)
+}
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    if (!CODE.test(at.filename)) return false
+
+    const text = String(at.text)
+    if (!MENTIONS.test(text)) return false
+
+    let ast: unknown
+    try {
+      ast = (parser.parseForESLint as (text: string, options: unknown) => { readonly ast: unknown })(text, {
+        range: true,
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+        ecmaFeatures: { jsx: true },
+      }).ast
+    } catch {
+      return false
+    }
+
+    const taken = new Set<string>()
+    reached(ast, new WeakSet<object>(), (one) => {
+      if (isBuiltin(one)) taken.add(one)
+    })
+
+    if (taken.size === 0) return false
+
+    return `this reaches ${[...taken].sort().join(', ')} straight from the runtime, and a node is handed everything it may touch`
+  },
+  proves: {
+    wrong: [
+      "import { readFileSync } from 'node:fs'\nexport const node = readFileSync\n",
+      "const { spawn } = require('child_process')\nexport const node = spawn\n",
+      "export const node = async () => await import('node:net')\n",
+    ],
+    right: [
+      "import { nd_read } from '../../operations/nodes.ts'\nexport const node = nd_read(async (hands) => await hands.store.get('a', 'b'))\n",
+      "import type { In } from './input.ts'\nexport const node = null as unknown as In\n",
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_unthreaded.ts

@@ -0,0 +1,419 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { parser } from 'typescript-eslint'
+
+import type { Slopnator } from '../slopnator.ts'
+
+import { descend, forget as forgetDescent, read, reached as fromThread, threading } from '../../core/descend.ts'
+import { findTree } from '../../core/tree.ts'
+
+const TREE_AT = findTree()
+const ROOT = `${TREE_AT.at.split('\\').join('/')}/`
+const TREE = TREE_AT.name
+const THREAD_AT = `${TREE_AT.name}/thread.ts`
+const FOLLOWABLE = /\.(ts|tsx|mts|cts|mjs|cjs|js)$/
+const LISTS = new Set(['declares', 'derives', 'seeds'])
+
+let threaders: ReadonlySet<string> | undefined
+let tree: Index | undefined
+const parsed = new Map<string, readonly Reach[]>()
+const broke = new Map<string, string>()
+
+export interface Reach {
+  readonly list?: 'declares' | 'derives' | 'seeds'
+  readonly at?: string
+  readonly id?: string
+  readonly describes?: string
+  readonly version?: number
+  readonly governs?: readonly string[]
+  readonly wears?: readonly string[]
+}
+
+export interface Meaning {
+  readonly id: string
+  readonly describes: string
+}
+
+const SAID = new Set(['at', 'id', 'describes'])
+
+interface Held {
+  readonly type?: string
+  readonly kind?: string
+  readonly name?: string
+  readonly value?: unknown
+  readonly key?: Held
+  readonly computed?: boolean
+  readonly id?: Held
+  readonly typeAnnotation?: Held
+  readonly typeName?: Held
+  readonly elementType?: Held
+  readonly properties?: readonly Held[]
+  readonly elements?: readonly (Held | null)[]
+  readonly declarations?: readonly Held[]
+  readonly body?: readonly Held[]
+  readonly declaration?: Held
+  readonly init?: Held
+}
+
+const keyOf = (property: Held): string | undefined => {
+  if (property.computed === true) return undefined
+  const key = property.key
+  if (key?.type === 'Identifier') return key.name
+  if (key?.type === 'Literal' && typeof key.value === 'string') return key.value
+  return undefined
+}
+
+function annotated(node: Held): string | undefined {
+  let held = node.id?.typeAnnotation?.typeAnnotation
+  while (held !== undefined && (held.type === 'TSArrayType' || held.type === 'TSTypeOperator')) {
+    held = held.elementType ?? held.typeAnnotation
+  }
+  return held?.typeName?.name
+}
+
+export const here = (filename: string): string => {
+  const path = filename.split('\\').join('/')
+  return path.startsWith(ROOT) ? path.slice(ROOT.length) : path
+}
+
+
+
+function rows(node: Held, list: Reach['list'], found: Reach[], hoisted: ReadonlyMap<string, Held>): void {
+  for (const one of node.elements ?? []) {
+    const element = one?.type === 'Identifier' && one.name !== undefined ? hoisted.get(one.name) : one
+    if (element === null || element === undefined || element.type !== 'ObjectExpression') continue
+    const said: { at?: string; id?: string; describes?: string; governs?: readonly string[]; wears?: readonly string[] } = {}
+    for (const property of element.properties ?? []) {
+      const key = keyOf(property)
+      const held = property.value as Held | undefined
+      if (key !== undefined && SAID.has(key) && held?.type === 'Literal' && typeof held.value === 'string') {
+        said[key as 'at' | 'id' | 'describes'] = held.value
+      }
+      if ((key === 'governs' || key === 'wears') && held?.type === 'ArrayExpression') {
+        said[key] = (held.elements ?? [])
+          .map((one) => (one?.type === 'Literal' && typeof one.value === 'string' ? one.value : undefined))
+          .filter((one): one is string => one !== undefined)
+      }
+      if (key !== undefined && LISTS.has(key) && held?.type === 'ArrayExpression') rows(held, key as Reach['list'], found, hoisted)
+    }
+    if (said.at !== undefined || said.id !== undefined) found.push({ list, ...said })
+  }
+}
+
+function reaching(text: string): readonly Reach[] {
+  const already = parsed.get(text)
+  if (already !== undefined) return already
+
+  const types = threading()
+  const found: Reach[] = []
+  const parse = (jsx: boolean): { ast: unknown } =>
+    (parser.parseForESLint as (t: string, o: unknown) => { ast: unknown })(text, {
+      range: true,
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      ecmaFeatures: { jsx },
+    })
+
+  const read = ((): { ast: unknown } | undefined => {
+    try {
+      return parse(true)
+    } catch {
+      try {
+        return parse(false)
+      } catch (error) {
+        broke.set(text, error instanceof Error ? (error.message.split('\n')[0] ?? error.message) : String(error))
+        return undefined
+      }
+    }
+  })()
+  if (read === undefined) {
+    parsed.set(text, found)
+    return found
+  }
+  const body = (read.ast as unknown as Held).body ?? []
+  const hoisted = new Map<string, Held>()
+  for (const statement of body) {
+    const held = statement.declaration ?? statement
+    if (held.type !== 'VariableDeclaration') continue
+    for (const one of held.declarations ?? []) {
+      const name = one.id?.name
+      if (name !== undefined && one.init?.type === 'ObjectExpression') hoisted.set(name, one.init)
+    }
+  }
+
+  for (const statement of body) {
+    const held = statement.declaration ?? statement
+    if (held.type !== 'VariableDeclaration' || held.kind !== 'const') continue
+    for (const one of held.declarations ?? []) {
+      if (!types.has(annotated(one) ?? '')) continue
+      const init = one.init
+      for (const node of init?.type === 'ArrayExpression' ? (init.elements ?? []) : [init]) {
+        if (node === null || node === undefined || node.type !== 'ObjectExpression') continue
+        const said: { id?: string; describes?: string; version?: number } = {}
+        for (const property of node.properties ?? []) {
+          const key = keyOf(property)
+          const value = property.value as Held | undefined
+          if ((key === 'id' || key === 'describes') && value?.type === 'Literal' && typeof value.value === 'string') said[key] = value.value
+          if (key === 'version' && value?.type === 'Literal' && typeof value.value === 'number') said.version = value.value
+          if (key !== undefined && LISTS.has(key) && value?.type === 'ArrayExpression') rows(value, key as Reach['list'], found, hoisted)
+        }
+        if (said.id !== undefined) found.push({ ...said })
+      }
+    }
+  }
+
+  parsed.set(text, found)
+  return found
+}
+
+export function atsIn(text: string, only?: ReadonlySet<string>): readonly string[] {
+  const found: string[] = []
+  for (const one of reaching(text)) {
+    if (only !== undefined && (one.list === undefined || !only.has(one.list))) continue
+    if (one.at !== undefined) found.push(one.at)
+  }
+  return found
+}
+
+export const rowsIn = (text: string): readonly Reach[] => reaching(text)
+
+const SCHEMA = /^export const ([A-Za-z]+)IslandSchema\b/m
+const DEFINE = /^export function (define[A-Za-z]+)\s*\(/m
+
+export type Governed =
+  | { readonly kind: 'file'; readonly at: string }
+  | { readonly kind: 'folder'; readonly under: string }
+  | { readonly kind: 'pattern'; readonly matching: string; readonly under: string }
+
+export function governedBy(one: string): Governed {
+  if (one.includes('*')) {
+    const cut = one.lastIndexOf('/', one.indexOf('*'))
+    return { kind: 'pattern', matching: one, under: cut === -1 ? '' : one.slice(0, cut + 1) }
+  }
+  if (one.endsWith('/')) return { kind: 'folder', under: one }
+  return { kind: 'file', at: one }
+}
+
+export const filesGoverned = (all: readonly string[]): readonly string[] =>
+  all.map(governedBy).flatMap((one) => (one.kind === 'file' ? [one.at] : []))
+
+export const foldersGoverned = (all: readonly string[]): readonly string[] =>
+  all.map(governedBy).flatMap((one) => (one.kind === 'file' ? [] : [one.under]))
+
+export function governs(all: readonly string[], path: string): boolean {
+  return all.map(governedBy).some((one) => {
+    if (one.kind === 'file') return path === one.at
+    if (one.kind === 'folder') return path.startsWith(one.under)
+    const tail = one.matching.slice(one.under.length).split('*').filter(Boolean)
+    const rest = path.startsWith(one.under) ? path.slice(one.under.length) : undefined
+    return rest !== undefined && tail.every((part) => rest.includes(part))
+  })
+}
+
+export interface Declared {
+  readonly id: string
+  readonly at: string
+  readonly describes: string
+  readonly governs: readonly string[]
+  readonly define?: string
+  readonly tree?: string
+  readonly member?: string
+}
+
+export function islandsDeclared(): readonly Declared[] {
+  const found: Declared[] = []
+  const seen = new Set<string>()
+  const all: Reach[] = []
+
+  for (const at of fromThread()) {
+    const held = read(at)
+    if (held === undefined) continue
+    if (unreadable(at, held) !== undefined) continue
+    all.push(...reaching(held))
+  }
+
+  for (const row of all) {
+    if (row.id === undefined || row.at === undefined || seen.has(row.at)) continue
+    const source = read(row.at)
+    if (source === undefined || !SCHEMA.test(source)) continue
+    seen.add(row.at)
+
+    const tree = `${TREE}/${row.id}.ts`
+    const named = all.find((one) => one.at === tree)?.id
+
+    found.push({
+      id: row.id,
+      at: row.at,
+      describes: row.describes ?? '',
+      governs: row.governs ?? [],
+      define: DEFINE.exec(source)?.[1],
+      ...(named === undefined ? {} : { tree, member: named }),
+    })
+  }
+
+  return found
+}
+
+export const declaresIsland = (text: string): string | undefined => SCHEMA.exec(text)?.[1]
+
+export function meaningsIn(text: string): readonly Meaning[] {
+  const found: Meaning[] = []
+  for (const one of reaching(text)) {
+    if (one.id === undefined) continue
+    found.push({ id: one.id, describes: one.describes ?? '' })
+  }
+  return found
+}
+
+export interface Index {
+  readonly reached: ReadonlySet<string>
+  readonly declared: ReadonlyMap<string, number>
+  readonly meanings: ReadonlyMap<string, ReadonlySet<string>>
+}
+
+
+function descended(): Index {
+  const pass = descend()
+  const reached = new Set<string>([THREAD_AT, ...pass.threaded.keys()])
+  const declared = new Map<string, number>()
+  for (const [at, held] of pass.threaded) declared.set(at, held.filter((one) => one.list === 'declares').length)
+  const meanings = new Map<string, ReadonlySet<string>>()
+  for (const [word, held] of pass.coined) meanings.set(word, new Set(held.said))
+  return { reached, declared, meanings }
+}
+
+export function index(): Index {
+  tree ??= descended()
+  return tree
+}
+
+export function forget(): void {
+  parsed.clear()
+  broke.clear()
+  threaders = undefined
+  tree = undefined
+  forgetDescent()
+}
+
+export const threaded = (): ReadonlySet<string> => index().reached
+
+export const parses = (path: string): boolean => FOLLOWABLE.test(path)
+
+export function unreadable(path: string, text: string): string | undefined {
+  if (!parses(path)) return undefined
+  atsIn(text)
+  const said = broke.get(text)
+  if (said === undefined) return undefined
+  return `this file cannot be parsed, so no law that reads its structure measured anything on it — ${said}`
+}
+
+export const names = (path: string, text: string): readonly string[] => (parses(path) ? atsIn(text) : [])
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+    if (path === THREAD_AT) return false
+    const why = unreadable(path, at.text)
+    if (why !== undefined) return why
+    const pass = descend()
+    if (pass.threaded.has(path)) return false
+    if (names(path, at.text).length > 0) return false
+    const by = pass.mentioned.get(path) ?? []
+    const cut = by.filter((one) => one !== THREAD_AT && !pass.threaded.has(one))
+    if (cut.length > 0) {
+      return `broken thread — ${cut.join(' and ')} names ${path}, and nothing declares ${cut.length === 1 ? 'it' : 'them'}, so the descent from ${THREAD_AT} never arrives`
+    }
+    if (by.length > 0) {
+      return `broken thread — ${by.join(' and ')} names ${path} and is itself declared, and the descent still never arrived, so the row was read and never walked`
+    }
+    return `nothing that traces back to ${TREE}/ names ${path}, so the descent from ${THREAD_AT} never reaches it`
+  },
+  proves: {
+    wrong: [
+      'export const ORPHAN = 2',
+      'export const LOOSE = { id: 2 }',
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export const OWNER = {\n  declares: [\n    {\n      at: 'scripts/_probe_bare.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_bare.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_bare.ts',
+      },
+      {
+        files: [
+          {
+            at: 'threads/_names_it.ts',
+            source:
+              "export const REAL: Threaded = {\n  declares: [\n    {\n      at: 'threads/_names_it.ts',\n    },\n  ],\n}\n\nexport const BARE = {\n  declares: [\n    {\n      at: 'scripts/_probe_after.ts',\n    },\n  ],\n}\n",
+          },
+          { at: 'scripts/_probe_after.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_after.ts',
+      },
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export let LOOSE = {\n  declares: [\n    {\n      at: 'scripts/_probe_let.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_let.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_let.ts',
+      },
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export var LOOSE = {\n  declares: [\n    {\n      at: 'scripts/_probe_var.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_var.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_var.ts',
+      },
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export default {\n  declares: [\n    {\n      at: 'scripts/_probe_default.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_default.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_default.ts',
+      },
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export function held() {\n  return {\n    declares: [\n      {\n        at: 'scripts/_probe_fn.ts',\n      },\n    ],\n  }\n}\n" },
+          { at: 'scripts/_probe_fn.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_fn.ts',
+      },
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export class Held {\n  held = {\n    declares: [\n      {\n        at: 'scripts/_probe_class.ts',\n      },\n    ],\n  }\n}\n" },
+          { at: 'scripts/_probe_class.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_class.ts',
+      },
+      {
+        files: [
+          {
+            at: 'threads/_names_it.ts',
+            source: "interface Held { declares: unknown[] }\nexport const FAKE: Held = {\n  declares: [\n    {\n      at: 'scripts/_probe_fake.ts',\n    },\n  ],\n}\n",
+          },
+          { at: 'scripts/_probe_fake.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_fake.ts',
+      },
+    ],
+    right: [
+      "export const HELD: Threaded = {\n  declares: [\n    {\n      at: 'threads/probe.tsx',\n    },\n  ],\n}",
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export const OWNER: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_child.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_child.ts', source: 'export const CHILD = 1\n' },
+        ],
+        at: 'scripts/_probe_child.ts',
+      },
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export const OWNER: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_parent.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_parent.ts', source: "export const MID: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_leaf.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_leaf.ts', source: 'export const LEAF = 1\n' },
+        ],
+        at: 'scripts/_probe_leaf.ts',
+      },
+    ],
+  },
+}