@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/slopnators/sl_door_in_a_node.ts

@@ -0,0 +1,250 @@
+import { resolve } from 'node:path'
+
+import ts from 'typescript'
+
+import { ROOT, configured, hosting } from '../../core/descend.ts'
+import { kind, readFileSync } from '../../integrations/disk.ts'
+import { OPENS } from '../../integrations/target.ts'
+
+import type { Slopnator } from '../slopnator.ts'
+import { here } from './sl_unthreaded.ts'
+
+const IMPORTED = 'import '
+
+const MADE = 'new '
+
+const RUNTIME = 'node:'
+
+const ANYWHERE = 'globalThis'
+
+const REQUIRED = 'require'
+
+const DECLARED = /\.d\.([cm]?)ts$/
+
+const READABLE = /\.(?:[cm]?[jt]s|[jt]sx)$/
+
+const plain = (specifier: string): string => (specifier.startsWith(RUNTIME) ? specifier.slice(RUNTIME.length) : specifier)
+
+interface Door {
+  readonly reach: string
+  readonly spelling: string
+}
+
+interface Doors {
+  readonly modules: ReadonlyMap<string, Door>
+  readonly globals: ReadonlyMap<string, Door>
+  readonly properties: ReadonlyMap<string, Door>
+}
+
+function doors(): Doors {
+  const modules = new Map<string, Door>()
+  const globals = new Map<string, Door>()
+  const properties = new Map<string, Door>()
+  for (const [reach, spellings] of Object.entries(OPENS)) {
+    for (const spelling of spellings) {
+      const door = { reach, spelling }
+      if (spelling.startsWith(IMPORTED)) {
+        const rest = spelling.slice(IMPORTED.length)
+        const dot = rest.lastIndexOf('.')
+        modules.set(plain(dot === -1 || rest.slice(dot).includes('/') ? rest : rest.slice(0, dot)), door)
+        continue
+      }
+      if (spelling.startsWith(MADE)) {
+        globals.set(spelling.slice(MADE.length), door)
+        continue
+      }
+      if (spelling.includes('.')) properties.set(spelling, door)
+      else globals.set(spelling, door)
+    }
+  }
+  return { modules, globals, properties }
+}
+
+const DOORS = doors()
+
+interface Brought {
+  readonly specifier: string
+  readonly line: number
+}
+
+const files = new Map<string, ts.SourceFile>()
+
+function parsed(at: string, text: string): ts.SourceFile {
+  const held = files.get(text)
+  if (held !== undefined) return held
+  const file = ts.createSourceFile(at, text, ts.ScriptTarget.Latest, true, at.endsWith('x') ? ts.ScriptKind.TSX : ts.ScriptKind.TS)
+  files.set(text, file)
+  return file
+}
+
+function brought(file: ts.SourceFile): readonly Brought[] {
+  const found: Brought[] = []
+  const line = (node: ts.Node): number => file.getLineAndCharacterOfPosition(node.getStart(file)).line + 1
+  const visit = (node: ts.Node): void => {
+    if (ts.isImportDeclaration(node) && node.importClause?.isTypeOnly !== true && ts.isStringLiteral(node.moduleSpecifier)) {
+      found.push({ specifier: node.moduleSpecifier.text, line: line(node) })
+    }
+    if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier)) {
+      found.push({ specifier: node.moduleSpecifier.text, line: line(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)) found.push({ specifier: first.text, line: line(node) })
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(file)
+  return found
+}
+
+const binds = (node: ts.Identifier): boolean => {
+  const parent = node.parent
+  return (
+    (ts.isVariableDeclaration(parent) ||
+      ts.isParameter(parent) ||
+      ts.isBindingElement(parent) ||
+      ts.isFunctionDeclaration(parent) ||
+      ts.isClassDeclaration(parent) ||
+      ts.isImportSpecifier(parent) ||
+      ts.isImportClause(parent) ||
+      ts.isNamespaceImport(parent)) &&
+    parent.name === node
+  )
+}
+
+const named = (node: ts.Node): boolean => (node.parent as { readonly name?: ts.Node } | undefined)?.name === node
+
+const opened = new Map<string, Door | undefined>()
+
+function opening(at: string, text: string): Door | undefined {
+  if (opened.has(text)) return opened.get(text)
+  const file = parsed(at, text)
+  let found: Door | undefined
+  for (const one of brought(file)) found ??= DOORS.modules.get(plain(one.specifier))
+  const bound = new Set<string>()
+  const collect = (node: ts.Node): void => {
+    if (ts.isIdentifier(node) && binds(node)) bound.add(node.text)
+    ts.forEachChild(node, collect)
+  }
+  collect(file)
+  const visit = (node: ts.Node): void => {
+    if (found !== undefined) return
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && !ts.isPartOfTypeNode(node)) {
+      const object = node.expression.text
+      found = DOORS.properties.get(object + '.' + node.name.text) ?? (object === ANYWHERE ? DOORS.globals.get(node.name.text) : undefined)
+    }
+    if (found === undefined && ts.isIdentifier(node) && !named(node) && !ts.isPartOfTypeNode(node) && !bound.has(node.text)) {
+      found = DOORS.globals.get(node.text)
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(file)
+  opened.set(text, found)
+  return found
+}
+
+let options: ts.CompilerOptions | undefined
+
+let host: ts.CompilerHost | undefined
+
+function resolvedOf(specifier: string, from: string): string | undefined {
+  options ??= configured().options
+  host ??= hosting(options)
+  const found = ts.resolveModuleName(specifier, from, options, host).resolvedModule
+  if (found === undefined) return undefined
+  const at = found.resolvedFileName
+  if (!DECLARED.test(at)) return at
+  const emitted = at.replace(DECLARED, '.$1js')
+  return kind(emitted) === 'file' ? emitted : undefined
+}
+
+const readable = (at: string): string | undefined => (READABLE.test(at) && kind(at) === 'file' ? readFileSync(at, 'utf8') : undefined)
+
+const shown = (chain: readonly string[], door: Door): string =>
+  chain.map((one) => '`' + one + '`').join(', which imports ') +
+  (door.spelling.startsWith(IMPORTED) ? ', which imports ' + door.spelling.slice(IMPORTED.length) : ', which reaches ' + door.spelling) +
+  ' — the ' +
+  door.reach +
+  ' reach, and no target declares it. Nothing prices that reach, replays it in a trial or refuses it. Declare the place with `thread create target`, require it on the operation, and call what the node is handed instead'
+
+function through(at: string, chain: readonly string[], seen: Set<string>): string | undefined {
+  const text = readable(at)
+  if (text === undefined) return undefined
+  const door = opening(at, text)
+  if (door !== undefined) return shown(chain, door)
+  for (const one of brought(parsed(at, text))) {
+    const next = resolvedOf(one.specifier, at)
+    if (next === undefined || seen.has(next)) continue
+    seen.add(next)
+    const found = through(next, [...chain, one.specifier], seen)
+    if (found !== undefined) return found
+  }
+  return undefined
+}
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+    if (!READABLE.test(path)) return false
+    const from = resolve(ROOT, path)
+    const seen = new Set<string>([from])
+    for (const one of brought(parsed(from, at.text))) {
+      const next = resolvedOf(one.specifier, from)
+      if (next === undefined || seen.has(next)) continue
+      seen.add(next)
+      const found = through(next, [one.specifier], seen)
+      if (found !== undefined) return 'line ' + String(one.line) + ': imports ' + found
+    }
+    return false
+  },
+  proves: {
+    wrong: [
+      {
+        files: [
+          { at: 'thread/integrations/cli.ts', source: "import { spawn } from 'node:child_process'\n\nexport const starts = (program: string): void => {\n  spawn(program)\n}\n" },
+          { at: 'operations/_probe_node.ts', source: "export { starts } from '../thread/integrations/cli.ts'\n" },
+        ],
+        at: 'operations/_probe_node.ts',
+      },
+      {
+        files: [
+          { at: 'thread/integrations/https.ts', source: "export const sendingHttp = async (address: string): Promise<number> => (await fetch(address)).status\n" },
+          { at: 'src/_probe_helper.ts', source: "import { sendingHttp } from '../thread/integrations/https.ts'\n\nexport const status = (address: string): Promise<number> => sendingHttp(address)\n" },
+          { at: 'operations/_probe_node.ts', source: "import { status } from '../src/_probe_helper.ts'\n\nexport const node = (address: string): Promise<number> => status(address)\n" },
+        ],
+        at: 'operations/_probe_node.ts',
+      },
+      {
+        files: [
+          { at: 'thread/integrations/disk.ts', source: "import * as disk from 'node:fs'\n\nexport const read = (at: string): string => disk.readFileSync(at, 'utf8')\n" },
+          { at: 'operations/_probe_node.ts', source: "export const node = async (at: string): Promise<string> => (await import('../thread/integrations/disk.ts')).read(at)\n" },
+        ],
+        at: 'operations/_probe_node.ts',
+      },
+    ],
+    right: [
+      {
+        files: [
+          { at: 'thread/operations/nodes.ts', source: "export const nd_action = <T>(run: T): T => run\n" },
+          { at: 'operations/_probe_node.ts', source: "import { nd_action } from '../thread/operations/nodes.ts'\n\nexport const node = nd_action(async () => 1)\n" },
+        ],
+        at: 'operations/_probe_node.ts',
+      },
+      {
+        files: [
+          { at: 'thread/integrations/cli.ts', source: "import { spawn } from 'node:child_process'\n\nexport interface Ran {\n  readonly out: string\n}\n\nexport const starts = (program: string): void => {\n  spawn(program)\n}\n" },
+          { at: 'operations/_probe_node.ts', source: "import type { Ran } from '../thread/integrations/cli.ts'\n\nexport const node = (ran: Ran): string => ran.out\n" },
+        ],
+        at: 'operations/_probe_node.ts',
+      },
+      {
+        files: [
+          { at: 'src/_probe_helper.ts', source: "const fetch = (said: string): string => said\n\nexport const shout = (said: string): string => fetch(said).toUpperCase()\n" },
+          { at: 'operations/_probe_node.ts', source: "import { shout } from '../src/_probe_helper.ts'\n\nexport const node = (): string => shout('a')\n" },
+        ],
+        at: 'operations/_probe_node.ts',
+      },
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_inert_island.js

@@ -1,7 +1,7 @@
-import { existsSync, readFileSync } from "../../core/files.js";
+import { existsSync, readFileSync } from '../../integrations/disk.js';
 import { resolve } from 'node:path';
-import { declaresIsland, here, rowsIn } from "./sl_unthreaded.js";
-import { findTree } from "../../core/tree.js";
+import { declaresIsland, here, rowsIn } from './sl_unthreaded.js';
+import { findTree } from '../../core/tree.js';
 const ROOT = findTree().at;
 const TREE = `${findTree().name}/`;
 function schemaAt(at) {
@@ -60,17 +60,19 @@ export const slopnator = {
         right: [
             {
                 files: [
-                    { at: 'threads/_inert_probe.ts', source: "export const M: Threaded = {\n  declares: [\n    { id: 'events', at: 'src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n" },
+                    { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly governs?: readonly 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/_inert_probe.ts',\n    },\n  ],\n}\n" },
+                    { at: 'threads/_inert_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    { id: 'events', at: 'src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n" },
                     { at: 'src/islands/events.ts', source: 'export const EventsIslandSchema = {}\n' },
                 ],
                 at: 'threads/_inert_probe.ts',
             },
             {
                 files: [
-                    {
-                        at: 'threads/_inert_probe.ts',
-                        source: "export const M: Threaded = {\n  declares: [\n    { id: 'a-file', at: 'threads/thread.ts' },\n  ],\n}\n",
-                    },
+                    { 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/_inert_probe.ts',\n    },\n  ],\n}\n" },
+                    { at: 'threads/_inert_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    { id: 'a-file', at: 'threads/_plain.ts' },\n  ],\n}\n" },
+                    { at: 'threads/_plain.ts', source: 'export const PLAIN = 1\n' },
                 ],
                 at: 'threads/_inert_probe.ts',
             },

package/dist/integrity/slopnators/sl_inert_island.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync } from '../../integrations/disk.ts'
 import { resolve } from 'node:path'
 
 import type { Slopnator } from '../slopnator.ts'
@@ -63,17 +63,19 @@ export const slopnator: Slopnator = {
     right: [
       {
         files: [
-          { at: 'threads/_inert_probe.ts', source: "export const M: Threaded = {\n  declares: [\n    { id: 'events', at: 'src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n" },
+          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly governs?: readonly 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/_inert_probe.ts',\n    },\n  ],\n}\n" },
+          { at: 'threads/_inert_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    { id: 'events', at: 'src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n" },
           { at: 'src/islands/events.ts', source: 'export const EventsIslandSchema = {}\n' },
         ],
         at: 'threads/_inert_probe.ts',
       },
       {
         files: [
-          {
-            at: 'threads/_inert_probe.ts',
-            source: "export const M: Threaded = {\n  declares: [\n    { id: 'a-file', at: 'threads/thread.ts' },\n  ],\n}\n",
-          },
+          { 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/_inert_probe.ts',\n    },\n  ],\n}\n" },
+          { at: 'threads/_inert_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    { id: 'a-file', at: 'threads/_plain.ts' },\n  ],\n}\n" },
+          { at: 'threads/_plain.ts', source: 'export const PLAIN = 1\n' },
         ],
         at: 'threads/_inert_probe.ts',
       },

package/dist/integrity/slopnators/sl_missing_row.js

@@ -1,33 +1,11 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "../../core/files.js";
+import { existsSync, readFileSync, readdirSync, statSync } from '../../integrations/disk.js';
 import { join } from 'node:path';
-import { ORGANISATION, ours } from "../../core/scope.js";
-import { findTree } from "../../core/tree.js";
-/**
- * A row the package still ships and the tree no longer holds.
- *
- * Read as TEXT, deliberately. Eight laws were once added whose walks imported a workspace package,
- * plain Node could not resolve it, `load()` swallowed the failure, and all eight read from every
- * caller exactly like laws finding nothing. Nothing here imports anything but node builtins.
- */
-/** A node: a const annotated `Threaded`. */
+import { ORGANISATION, ours } from '../../core/scope.js';
+import { findTree } from '../../core/tree.js';
 const NODE = /export\s+const\s+[A-Za-z_$][\w$]*\s*:\s*Threaded\b/;
-/**
- * Where a node's rows are written.
- *
- * A node may open the list inline, or name a `declares` array declared beside it and reference it by
- * shorthand. Only the first was read, so `@thread/ui`'s tokens and signals nodes — 107 of its 178
- * shipped rows — reported as shipping nothing, and every one of them could be deleted in silence.
- */
 const SHAPES = [/declares:\s*\[/g, /export\s+const\s+declares\b[^\n]*?=\s*\[/g];
-/**
- * How a row states its id.
- *
- * A row may be an object literal, or a call to a factory declared beside the list that takes the id
- * first. Only the literal was read, which is the other half of why tokens and signals were invisible.
- */
 const ID = /\bid:\s*'([^']+)'/g;
 const CALLED = /(?:^|[\s,[(])[a-zA-Z_$][\w$]*\(\s*'([^']+)'/g;
-/** Strings out first, so a fixture that PRINTS a declaration is not read as being one. */
 const QUOTED = /"(?:[^"\\\n]|\\.)*"|`(?:[^`\\]|\\.)*`/g;
 function closes(code, from) {
     let depth = 0;
@@ -42,13 +20,6 @@ function closes(code, from) {
     }
     return -1;
 }
-/**
- * What a package SHIPS: only the ids inside a `declares` list.
- *
- * It was every id anywhere in a file that held one such list, which read an `Appending`'s own `id`
- * as a shipped row — `@thread/operations` was reported as shipping `seed-generator`, the name of a
- * row it asks an app to APPEND into another list, not one it declares.
- */
 function shippedIn(text) {
     const code = text.replace(QUOTED, '""');
     if (!NODE.test(code))
@@ -69,13 +40,6 @@ function shippedIn(text) {
     }
     return found;
 }
-/**
- * What a tree HOLDS: every id in it, whichever list it sits in.
- *
- * Gating this on `declares` made every row in `derivation.ts` invisible, because its node states no
- * `declares` at all and its rows live in `GENERATORS`. A row plainly on disk read as missing, and
- * running the command this law recommends would not have cleared the finding.
- */
 function heldIn(text) {
     const code = text.replace(QUOTED, '""');
     const found = new Set();
@@ -93,7 +57,6 @@ function filesIn(dir) {
         return [];
     }
 }
-/** Every installed thread package that ships nodes of its own. */
 function installed(root) {
     const at = join(root, 'node_modules', ORGANISATION);
     const found = [];
@@ -126,19 +89,10 @@ function read(path) {
 export const slopnator = {
     checks: (root) => {
         const tree = findTree(root);
-        /* Every id the tree holds, across every node in it. */
         const held = new Set();
         for (const path of filesIn(tree.dir))
             for (const one of heldIn(read(path)))
                 held.add(one);
-        /*
-         * Only packages this tree ATTACHED, not every one installed.
-         *
-         * Measured by running it: the first version named `@thread/knowledge`, which the audit app has
-         * in `node_modules` and never attached — so the law demanded rows for a package nobody had
-         * asked for. A package is attached when the tree names a file inside it; one nothing points at
-         * is a dependency, and a dependency ships nothing this tree promised to hold.
-         */
         const wired = new Set();
         for (const path of filesIn(tree.dir)) {
             for (const one of read(path).matchAll(/node_modules\/(@[\w.-]+\/[\w.-]+)\//g))
@@ -153,7 +107,6 @@ export const slopnator = {
                 if (shipped.size === 0)
                     continue;
                 for (const id of [...shipped].sort()) {
-                    /* The node's own id names the list, not a row in it. */
                     if (held.has(id))
                         continue;
                     found.push(`${pkg.name} ships \`${id}\` and this tree does not hold it — run \`thread attach ${pkg.name}\` to put it back`);
@@ -175,7 +128,9 @@ export const slopnator = {
         right: [
             {
                 files: [
-                    { at: '_threads/_probe_missing.ts', source: "import type { Threaded } from '../../core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    {\n      id: 'colour',\n    },\n    {\n      id: 'missing-thing',\n    },\n    {\n      at: 'node_modules/@prestack/thread-probe/dist/foo.ts',\n    },\n  ],\n}\n" },
+                    { 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_missing.ts',\n    },\n  ],\n}\n" },
+                    { at: '_threads/_probe_missing.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    {\n      id: 'colour',\n    },\n    {\n      id: 'missing-thing',\n    },\n    {\n      at: 'node_modules/@prestack/thread-probe/dist/foo.ts',\n    },\n  ],\n}\n" },
                     { at: 'node_modules/@prestack/thread-probe/dist/foo.ts', source: "export const PKG: Threaded = {\n  declares: [\n    {\n      id: 'missing-thing',\n    },\n  ],\n}\n" },
                 ],
                 at: '_threads/_probe_missing.ts',

package/dist/integrity/slopnators/sl_missing_row.ts

@@ -1,40 +1,17 @@
-import { existsSync, readFileSync, readdirSync, statSync } from '../../core/files.ts'
+import { existsSync, readFileSync, readdirSync, statSync } from '../../integrations/disk.ts'
 import { join } from 'node:path'
 
 import type { Slopnator } from '../slopnator.ts'
 import { ORGANISATION, ours } from '../../core/scope.ts'
 import { findTree } from '../../core/tree.ts'
 
-/**
- * A row the package still ships and the tree no longer holds.
- *
- * Read as TEXT, deliberately. Eight laws were once added whose walks imported a workspace package,
- * plain Node could not resolve it, `load()` swallowed the failure, and all eight read from every
- * caller exactly like laws finding nothing. Nothing here imports anything but node builtins.
- */
-
-/** A node: a const annotated `Threaded`. */
 const NODE = /export\s+const\s+[A-Za-z_$][\w$]*\s*:\s*Threaded\b/
 
-/**
- * Where a node's rows are written.
- *
- * A node may open the list inline, or name a `declares` array declared beside it and reference it by
- * shorthand. Only the first was read, so `@thread/ui`'s tokens and signals nodes — 107 of its 178
- * shipped rows — reported as shipping nothing, and every one of them could be deleted in silence.
- */
 const SHAPES = [/declares:\s*\[/g, /export\s+const\s+declares\b[^\n]*?=\s*\[/g]
 
-/**
- * How a row states its id.
- *
- * A row may be an object literal, or a call to a factory declared beside the list that takes the id
- * first. Only the literal was read, which is the other half of why tokens and signals were invisible.
- */
 const ID = /\bid:\s*'([^']+)'/g
 const CALLED = /(?:^|[\s,[(])[a-zA-Z_$][\w$]*\(\s*'([^']+)'/g
 
-/** Strings out first, so a fixture that PRINTS a declaration is not read as being one. */
 const QUOTED = /"(?:[^"\\\n]|\\.)*"|`(?:[^`\\]|\\.)*`/g
 
 function closes(code: string, from: number): number {
@@ -49,13 +26,6 @@ function closes(code: string, from: number): number {
   return -1
 }
 
-/**
- * What a package SHIPS: only the ids inside a `declares` list.
- *
- * It was every id anywhere in a file that held one such list, which read an `Appending`'s own `id`
- * as a shipped row — `@thread/operations` was reported as shipping `seed-generator`, the name of a
- * row it asks an app to APPEND into another list, not one it declares.
- */
 function shippedIn(text: string): ReadonlySet<string> {
   const code = text.replace(QUOTED, '""')
   if (!NODE.test(code)) return new Set()
@@ -73,13 +43,6 @@ function shippedIn(text: string): ReadonlySet<string> {
   return found
 }
 
-/**
- * What a tree HOLDS: every id in it, whichever list it sits in.
- *
- * Gating this on `declares` made every row in `derivation.ts` invisible, because its node states no
- * `declares` at all and its rows live in `GENERATORS`. A row plainly on disk read as missing, and
- * running the command this law recommends would not have cleared the finding.
- */
 function heldIn(text: string): ReadonlySet<string> {
   const code = text.replace(QUOTED, '""')
   const found = new Set<string>()
@@ -96,7 +59,6 @@ function filesIn(dir: string): readonly string[] {
   }
 }
 
-/** Every installed thread package that ships nodes of its own. */
 function installed(root: string): readonly { readonly name: string; readonly src: string }[] {
   const at = join(root, 'node_modules', ORGANISATION)
   const found: { name: string; src: string }[] = []
@@ -129,18 +91,9 @@ export const slopnator: Slopnator = {
   checks: (root) => {
     const tree = findTree(root)
 
-    /* Every id the tree holds, across every node in it. */
     const held = new Set<string>()
     for (const path of filesIn(tree.dir)) for (const one of heldIn(read(path))) held.add(one)
 
-    /*
-     * Only packages this tree ATTACHED, not every one installed.
-     *
-     * Measured by running it: the first version named `@thread/knowledge`, which the audit app has
-     * in `node_modules` and never attached — so the law demanded rows for a package nobody had
-     * asked for. A package is attached when the tree names a file inside it; one nothing points at
-     * is a dependency, and a dependency ships nothing this tree promised to hold.
-     */
     const wired = new Set<string>()
     for (const path of filesIn(tree.dir)) {
       for (const one of read(path).matchAll(/node_modules\/(@[\w.-]+\/[\w.-]+)\//g)) wired.add(one[1] ?? '')
@@ -153,7 +106,6 @@ export const slopnator: Slopnator = {
         const shipped = shippedIn(read(path))
         if (shipped.size === 0) continue
         for (const id of [...shipped].sort()) {
-          /* The node's own id names the list, not a row in it. */
           if (held.has(id)) continue
           found.push(
             `${pkg.name} ships \`${id}\` and this tree does not hold it — run \`thread attach ${pkg.name}\` to put it back`,
@@ -176,7 +128,9 @@ export const slopnator: Slopnator = {
     right: [
       {
         files: [
-          { at: '_threads/_probe_missing.ts', source: "import type { Threaded } from '../../core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    {\n      id: 'colour',\n    },\n    {\n      id: 'missing-thing',\n    },\n    {\n      at: 'node_modules/@prestack/thread-probe/dist/foo.ts',\n    },\n  ],\n}\n" },
+          { 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_missing.ts',\n    },\n  ],\n}\n" },
+          { at: '_threads/_probe_missing.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    {\n      id: 'colour',\n    },\n    {\n      id: 'missing-thing',\n    },\n    {\n      at: 'node_modules/@prestack/thread-probe/dist/foo.ts',\n    },\n  ],\n}\n" },
           { at: 'node_modules/@prestack/thread-probe/dist/foo.ts', source: "export const PKG: Threaded = {\n  declares: [\n    {\n      id: 'missing-thing',\n    },\n  ],\n}\n" },
         ],
         at: '_threads/_probe_missing.ts',

package/dist/integrity/slopnators/sl_no_barrel.js

@@ -1,4 +1,4 @@
-import { here } from "./sl_unthreaded.js";
+import { here } from './sl_unthreaded.js';
 const BARREL_NAME = /(^|\/)index\.(ts|tsx|mts|cts|js|mjs|cjs)$/;
 const CODE = /\.(ts|tsx|mts|cts|js|mjs|cjs)$/;
 const SAYS = "can't do barrels lazy ass";

package/dist/integrity/slopnators/sl_no_child_process.js

@@ -1,38 +1,56 @@
-const STARTS_A_PROCESS = new Set(['node:child_process', 'child_process']);
+import { dirname, join, normalize } from 'node:path';
+import { ROOT, descend, read, reached } from '../../core/descend.js';
+import { rowsIn } from './sl_unthreaded.js';
+const DOOR = 'programs';
+const ROOTED = ROOT + '/';
+const slash = (one) => one.split('\\').join('/');
+const bare = (one) => one.replace(/\.[^./]+$/, '');
+function doorway() {
+    descend();
+    for (const at of reached()) {
+        const text = read(at);
+        if (text === undefined)
+            continue;
+        for (const one of rowsIn(text)) {
+            if (one.id === DOOR && one.at !== undefined)
+                return one.at;
+        }
+    }
+    return undefined;
+}
 const named = (held) => {
     const one = held;
     return one?.type === 'Literal' && typeof one.value === 'string' ? one.value : undefined;
 };
 export const slopnator = {
     on: ['ImportDeclaration', 'ImportExpression', 'CallExpression'],
-    holds: (node) => {
+    holds: (node, at) => {
         const held = node;
         const from = held.type === 'ImportDeclaration' || held.type === 'ImportExpression'
             ? (named(held.source) ?? named(held.arguments?.[0]))
             : held.callee?.name === 'require'
                 ? named(held.arguments?.[0])
                 : undefined;
-        if (from === undefined || !STARTS_A_PROCESS.has(from))
+        if (from === undefined)
             return false;
-        return `it imports \`${from}\`, so this slopnator can start a process — and whatever it starts can reach back into the enforcement that called it`;
+        const door = doorway();
+        if (door === undefined)
+            return false;
+        const here = at.filename.startsWith(ROOTED) ? at.filename.slice(ROOTED.length) : at.filename;
+        const aimed = from.startsWith('.') ? slash(normalize(join(dirname(here), from))) : from;
+        if (bare(aimed) !== bare(door))
+            return false;
+        return ('it imports ' + door + ', which is where every process this framework starts comes from. A check that can reach it can ' +
+            'start something, and whatever it starts can reach back into the enforcement that called it');
     },
     proves: {
         wrong: [
             {
                 files: [
-                    {
-                        at: 'thread/integrity/slopnators/sl_probe_spawn.ts',
-                        source: "import { spawnSync } from 'node:child_process'\nexport const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
-                    },
-                ],
-                at: 'thread/integrity/slopnators/sl_probe_spawn.ts',
-            },
-            {
-                files: [
-                    {
-                        at: 'thread/integrity/slopnators/sl_probe_spawn.ts',
-                        source: "const held = await import('child_process')\nexport const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
-                    },
+                    { 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_programs.ts',\n    },\n  ],\n}\n" },
+                    { at: 'threads/_probe_programs.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const INTEGRATIONS: Threaded = {\n  id: 'integrations',\n  declares: [\n    {\n      id: 'programs',\n      at: 'thread/integrations/cli.ts',\n    },\n  ],\n}\n" },
+                    { at: 'thread/integrity/slopnators/sl_probe_spawn.ts', source: "import { starts } from '../../integrations/cli.ts'\nexport const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n" },
                 ],
                 at: 'thread/integrity/slopnators/sl_probe_spawn.ts',
             },
@@ -42,7 +60,7 @@ export const slopnator = {
                 files: [
                     {
                         at: 'thread/integrity/slopnators/sl_probe_spawn.ts',
-                        source: "import { readFileSync } from 'node:fs'\nexport const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
+                        source: "import { dirname } from 'node:path'\nexport const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
                     },
                 ],
                 at: 'thread/integrity/slopnators/sl_probe_spawn.ts',