@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/slopnators/sl_undeclared_list.ts

@@ -0,0 +1,358 @@
+import { dirname, resolve } from 'node:path'
+
+import ts from 'typescript'
+
+import { readFileSync } from '../../integrations/disk.ts'
+
+import type { Slopnator, SlopnatorContext } from '../slopnator.ts'
+
+const LIST = 2
+
+interface Held {
+  readonly type?: string
+  readonly value?: unknown
+  readonly name?: string
+  readonly operator?: string
+  readonly elements?: readonly (Held | null)[]
+  readonly properties?: readonly (Held | null)[]
+  readonly arguments?: readonly Held[]
+  readonly init?: Held | null
+  readonly id?: { readonly type?: string; readonly name?: string }
+  readonly callee?: Held
+  readonly object?: Held
+  readonly property?: Held
+  readonly expression?: Held
+  readonly argument?: Held | null
+  readonly test?: Held | null
+  readonly consequent?: Held | null
+  readonly alternate?: Held | null
+  readonly body?: readonly (Held | null)[]
+}
+
+const WIDENED = 'TSAsExpression'
+
+function bare(held: Held | null | undefined): Held | undefined {
+  let one = held ?? undefined
+  while (one?.type === WIDENED) one = one.expression
+  return one
+}
+
+const spoken = (held: Held | null | undefined): boolean => {
+  const one = bare(held)
+  return one?.type === 'Literal' && typeof one.value === 'string'
+}
+
+const strings = (held: Held | null | undefined): boolean => {
+  const one = bare(held)
+  if (one?.type !== 'ArrayExpression') return false
+  const all = one.elements ?? []
+  return all.length >= LIST && all.every((each) => spoken(each) || woven(each))
+}
+
+const SPREAD = 'SpreadElement'
+
+function woven(held: Held | null | undefined): boolean {
+  const one = bare(held)
+  if (one?.type !== SPREAD) return false
+  let words = 0
+  let other = false
+  const walk = (node: unknown, seen: Set<unknown>): void => {
+    if (node === null || typeof node !== 'object' || seen.has(node)) return
+    seen.add(node)
+    if (Array.isArray(node)) {
+      for (const each of node) walk(each, seen)
+      return
+    }
+    const held = node as Held
+    if (held.type === 'Literal') {
+      if (typeof held.value === 'string') words += 1
+      else other = true
+      return
+    }
+    for (const [key, each] of Object.entries(node as Record<string, unknown>)) {
+      if (key !== BACK) walk(each, seen)
+    }
+  }
+  walk(one.argument, new Set())
+  return words > 0 && !other
+}
+
+function valued(held: Held): readonly Held[] {
+  const found: Held[] = []
+  for (const one of held.properties ?? []) {
+    if (one?.type === 'Property') found.push(one.value as Held)
+  }
+  return found
+}
+
+function tabled(held: Held | null | undefined, seen: Set<unknown>): boolean {
+  const one = bare(held)
+  if (one === undefined || one.type !== 'ObjectExpression' || seen.has(one)) return false
+  seen.add(one)
+  const all = valued(one)
+  if (all.filter((each) => spoken(each)).length >= LIST) return true
+  return all.some((each) => strings(each) || tabled(each, seen))
+}
+
+function drawn(held: Held): string | undefined {
+  if (held.type !== 'NewExpression' || held.callee?.type !== 'Identifier' || held.callee.name !== 'Set') return undefined
+  const only = held.arguments ?? []
+  if (only.length !== 1) return undefined
+  const call = bare(only[0])
+  const callee = call?.callee
+  if (call?.type !== 'CallExpression' || callee?.type !== 'MemberExpression') return undefined
+  if (callee.object?.type !== 'Identifier' || callee.object.name !== 'Object') return undefined
+  const asked = callee.property?.name
+  if (asked !== 'keys' && asked !== 'values') return undefined
+  const from = bare((call.arguments ?? [])[0])
+  return from?.type === 'Identifier' ? from.name : undefined
+}
+
+function adapted(node: ts.Node): Held | undefined {
+  if (ts.isAsExpression(node) || ts.isParenthesizedExpression(node)) {
+    const inner = adapted(node.expression)
+    return inner === undefined ? undefined : { type: WIDENED, expression: inner }
+  }
+  if (ts.isStringLiteral(node)) return { type: 'Literal', value: node.text }
+  if (ts.isSpreadElement(node)) return { type: SPREAD, argument: adapted(node.expression) ?? null }
+  if (ts.isCallExpression(node)) {
+    return { type: 'CallExpression', arguments: node.arguments.map((one) => adapted(one)).filter((one): one is Held => one !== undefined) }
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    return { type: 'ArrayExpression', elements: node.elements.map((one) => adapted(one) ?? null) }
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    const properties: Held[] = []
+    for (const one of node.properties) {
+      if (!ts.isPropertyAssignment(one)) continue
+      const value = adapted(one.initializer)
+      if (value !== undefined) properties.push({ type: 'Property', value })
+    }
+    return { type: 'ObjectExpression', properties }
+  }
+  return undefined
+}
+
+function parsed(at: string, text: string): ts.SourceFile {
+  return ts.createSourceFile(at, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
+}
+
+function brought(source: ts.SourceFile, name: string): string | undefined {
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue
+    const bindings = statement.importClause?.namedBindings
+    if (bindings === undefined || !ts.isNamedImports(bindings)) continue
+    if (!bindings.elements.some((one) => one.name.text === name)) continue
+    return statement.moduleSpecifier.text
+  }
+  return undefined
+}
+
+function elsewhere(at: SlopnatorContext, name: string): Held | undefined {
+  const specifier = brought(parsed(at.filename, at.text), name)
+  if (specifier === undefined || !specifier.startsWith('.')) return undefined
+  const path = resolve(dirname(at.filename), specifier)
+  let text: string
+  try {
+    text = readFileSync(path, 'utf8')
+  } catch {
+    return undefined
+  }
+  for (const statement of parsed(path, text).statements) {
+    if (!ts.isVariableStatement(statement)) continue
+    for (const one of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(one.name) || one.name.text !== name || one.initializer === undefined) continue
+      return adapted(one.initializer)
+    }
+  }
+  return undefined
+}
+
+function initOf(held: unknown, name: string, seen: Set<unknown>): Held | undefined {
+  if (held === null || typeof held !== 'object' || seen.has(held)) return undefined
+  seen.add(held)
+  if (Array.isArray(held)) {
+    for (const one of held) {
+      const found = initOf(one, name, seen)
+      if (found !== undefined) return found
+    }
+    return undefined
+  }
+  const node = held as Held
+  const init = node.init ?? undefined
+  if (node.type === 'VariableDeclarator' && node.id?.type === 'Identifier' && node.id.name === name && init !== undefined) return init
+  for (const [key, one] of Object.entries(held as Record<string, unknown>)) {
+    if (key === BACK) continue
+    const found = initOf(one, name, seen)
+    if (found !== undefined) return found
+  }
+  return undefined
+}
+
+function listed(init: Held | null | undefined, program: unknown, at: SlopnatorContext, through: ReadonlySet<string>): boolean {
+  const one = bare(init)
+  if (one === undefined) return false
+  if (strings(one)) return true
+  if (tabled(one, new Set())) return true
+  if (one.type === 'NewExpression' || one.type === 'CallExpression') {
+    const only = one.arguments ?? []
+    if (only.length === 1 && strings(only[0])) return true
+  }
+  const from = drawn(one)
+  if (from === undefined || through.has(from)) return false
+  const followed = new Set(through)
+  followed.add(from)
+  const here = initOf(program, from, new Set())
+  return listed(here ?? elsewhere(at, from), program, at, followed)
+}
+
+const asks = (held: Held | undefined, name: string): boolean => {
+  const callee = held?.callee
+  if (held?.type !== 'CallExpression' || callee?.type !== 'MemberExpression') return false
+  const on = bare(callee.object)
+  if (on?.type !== 'Identifier' || on.name !== name) return false
+  const said = callee.property?.name
+  return said === 'has' || said === 'includes'
+}
+
+const BACK = 'parent'
+
+function asking(held: unknown, name: string, seen: Set<unknown>): boolean {
+  if (held === null || typeof held !== 'object' || seen.has(held)) return false
+  seen.add(held)
+  if (Array.isArray(held)) return held.some((one) => asking(one, name, seen))
+  if (asks(held as Held, name)) return true
+  return Object.entries(held as Record<string, unknown>).some(([key, one]) => key !== BACK && asking(one, name, seen))
+}
+
+function consults(node: Held, name: string): boolean {
+  if (node.type === 'MemberExpression') {
+    const on = bare(node.object)
+    if (on?.type === 'Identifier' && on.name === name) return true
+  }
+  const callee = node.callee
+  if (node.type !== 'CallExpression' || callee?.type !== 'MemberExpression') return false
+  if (callee.object?.type !== 'Identifier' || callee.object.name !== 'Object') return false
+  const only = node.arguments ?? []
+  const from = bare(only[0])
+  return only.length === 1 && from?.type === 'Identifier' && from.name === name
+}
+
+function consulted(held: unknown, name: string, seen: Set<unknown>): boolean {
+  if (held === null || typeof held !== 'object' || seen.has(held)) return false
+  seen.add(held)
+  if (Array.isArray(held)) return held.some((one) => consulted(one, name, seen))
+  if (consults(held as Held, name)) return true
+  return Object.entries(held as Record<string, unknown>).some(([key, one]) => key !== BACK && consulted(one, name, seen))
+}
+
+function continues(held: Held | null | undefined): boolean {
+  if (held === null || held === undefined) return false
+  if (held.type === 'ContinueStatement') return true
+  if (held.type !== 'BlockStatement') return false
+  return (held.body ?? []).some((one) => one?.type === 'ContinueStatement')
+}
+
+const LEAVES = 'ReturnStatement'
+
+const THROWN = 'ThrowStatement'
+
+const leaving = (one: Held | null | undefined): boolean => one?.type === LEAVES || one?.type === THROWN
+
+function exits(held: Held | null | undefined): boolean {
+  if (held === null || held === undefined) return false
+  if (leaving(held)) return true
+  if (held.type !== 'BlockStatement') return false
+  return (held.body ?? []).some((one) => leaving(one))
+}
+
+function look(held: unknown, name: string, found: { gates: boolean; skips: boolean }, seen: Set<unknown>): void {
+  if (held === null || typeof held !== 'object' || seen.has(held)) return
+  seen.add(held)
+  if (Array.isArray(held)) {
+    for (const one of held) look(one, name, found, seen)
+    return
+  }
+  const node = held as Held
+  if (node.type === 'UnaryExpression' && node.operator === '!' && asks(node.argument ?? undefined, name)) {
+    found.skips = true
+    return
+  }
+  if (node.type === 'IfStatement' && continues(node.consequent) && asking(node.test, name, new Set())) {
+    found.skips = true
+    look(node.consequent, name, found, seen)
+    look(node.alternate, name, found, seen)
+    return
+  }
+  if (node.type === 'IfStatement' && exits(node.consequent) && asking(node.test, name, new Set())) {
+    found.gates = true
+    return
+  }
+  if (asks(node, name)) {
+    found.gates = true
+    return
+  }
+  for (const [key, one] of Object.entries(node as Record<string, unknown>)) {
+    if (key !== BACK) look(one, name, found, seen)
+  }
+}
+
+export const slopnator: Slopnator = {
+  on: ['VariableDeclarator'],
+  holds: (node, at) => {
+    const held = node as Held
+    const program = at.ancestors().find((one) => (one as Held | undefined)?.type === 'Program')
+    if (!listed(held.init, program, at, new Set<string>())) return false
+    const named = held.id?.type === 'Identifier' ? held.id.name : undefined
+    const table = bare(held.init)?.type === 'ObjectExpression'
+    if (table && (named === undefined || !consulted(program, named, new Set()))) return false
+    if (named !== undefined) {
+      const found = { gates: false, skips: false }
+      look(program, named, found, new Set())
+      if (!found.gates && found.skips) return false
+    }
+    return (
+      `\`${named ?? 'this'}\` is ${table ? 'a table' : 'a list'} of words written out here and this check refuses what is IN it, so ` +
+      'whatever breaks the rule under a name nobody typed walks straight past. Wrapping them in `as const`, nesting them under a key, ' +
+      'or building a set out of the keys leaves the same list one step further out of sight. A list that decides what a check CATCHES ' +
+      'has to come from the tree: `thread inspect <word>` names the row that coins any word you need, and a check that reads those ' +
+      'rows widens when the tree does. A list a check only SKIPS is left alone, because adding a word to one of those makes it ' +
+      'stricter and it can never go blind.'
+    )
+  },
+  proves: {
+    wrong: [
+      "const CROSSINGS = ['fetch', 'setTimeout', 'setInterval']",
+      "const STARTS = new Set(['node:child_process', 'child_process'])\nexport const opens = (from: string): boolean => {\n  if (!STARTS.has(from)) return false\n  return true\n}",
+      "const GLOBALS = new Set(['Date', 'performance', 'Math'])",
+      "const MOVES = new Set(['push', 'replace'])\nexport const moved = (one: string): boolean => MOVES.has(one)",
+      "const SURFACES = ['cli', 'api', 'mcp'] as const\nexport const surfaced = (one: string): boolean => (SURFACES as readonly string[]).includes(one)",
+      "const MOVING = { globals: ['window', 'globalThis'], histories: ['router', 'history'] }\nexport const moves = (one: string): boolean => MOVING.globals.includes(one)",
+      "const HANDED_BY = { postgres: 'store', pglite: 'store', https: 'http' }\nexport const handedBy = (reach: string): string => HANDED_BY[reach] ?? reach",
+      "const HANDS = { postgres: 'store', pglite: 'store' }\nconst PINS = new Set(Object.keys(HANDS))\nexport const pinned = (one: string): boolean => PINS.has(one)",
+      {
+        files: [
+          { at: 'threads/held.ts', source: "export const PINNED = { clock: ['Date.now', 'setTimeout'] }\n" },
+          { at: 'threads/slopnators/sl_probe_followed.ts', source: "import { PINNED } from '../held.ts'\n\nconst PINS = new Set(Object.keys(PINNED))\nexport const pinned = (one: string): boolean => PINS.has(one)\n" },
+        ],
+        at: 'threads/slopnators/sl_probe_followed.ts',
+      },
+    ],
+    right: [
+      'const CROSSINGS = declared()',
+      "const UNDER = 'operations/'",
+      "const COMMON = new Set(['a', 'the'])\nexport const words = (all: readonly string[]): readonly string[] => all.filter((one) => !COMMON.has(one))",
+      "const SKIP = new Set(['dist', 'node_modules'])\nexport function walk(names: readonly string[]): number {\n  let seen = 0\n  for (const name of names) {\n    if (SKIP.has(name)) continue\n    seen += 1\n  }\n  return seen\n}",
+      "const LEFT = ['dist', 'node_modules'] as const\nexport function walked(names: readonly string[]): number {\n  let seen = 0\n  for (const name of names) {\n    if ((LEFT as readonly string[]).includes(name)) continue\n    seen += 1\n  }\n  return seen\n}",
+      "export const SAYS = { cli: 'runs at a terminal', api: 'answers a request' }",
+      {
+        files: [
+          { at: 'threads/made.ts', source: "export const MADE = declared()\n" },
+          { at: 'threads/slopnators/sl_probe_derived.ts', source: "import { MADE } from '../made.ts'\n\nconst PICKED = new Set(Object.keys(MADE))\nexport const picked = (one: string): boolean => PICKED.has(one)\n" },
+        ],
+        at: 'threads/slopnators/sl_probe_derived.ts',
+      },
+      "export const slopnator = { on: ['CallExpression', 'NewExpression'], holds: () => false, proves: { wrong: ['new Date()'], right: ['const at = 1'] } }",
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_undeclared_node.js

@@ -1,15 +1,5 @@
 import { dirname, join, normalize } from 'node:path';
-import { here, index, parses, unreadable } from "./sl_unthreaded.js";
-/*
- * Every string this file writes, whatever it writes it for.
- *
- * The first reading matched `node: '<name>'`, which was the shape when an operation named its node
- * in a string beside a step of its own; a node builds its own span now, so that matched nothing on
- * any real file. The second matched `import … from '<path>'`, which was the one route anybody had
- * thought of — and a dynamic `import()`, a `require()` and an `export … from` each walked straight
- * through it, measured on a real tree. Enumerating the ways in is how a refusal ends up as a list of
- * whatever somebody happened to try. What matters is the path, not the syntax carrying it.
- */
+import { here, index, parses, unreadable } from './sl_unthreaded.js';
 const SAID = /'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)"|`((?:[^`\\$]|\\.)*)`/g;
 const RELATIVE = /^\.\.?\//;
 const UNDER = 'nodes/';

package/dist/integrity/slopnators/sl_undeclared_node.ts

@@ -3,16 +3,6 @@ import { dirname, join, normalize } from 'node:path'
 import type { Slopnator } from '../slopnator.ts'
 import { here, index, parses, unreadable } from './sl_unthreaded.ts'
 
-/*
- * Every string this file writes, whatever it writes it for.
- *
- * The first reading matched `node: '<name>'`, which was the shape when an operation named its node
- * in a string beside a step of its own; a node builds its own span now, so that matched nothing on
- * any real file. The second matched `import … from '<path>'`, which was the one route anybody had
- * thought of — and a dynamic `import()`, a `require()` and an `export … from` each walked straight
- * through it, measured on a real tree. Enumerating the ways in is how a refusal ends up as a list of
- * whatever somebody happened to try. What matters is the path, not the syntax carrying it.
- */
 const SAID = /'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)"|`((?:[^`\\$]|\\.)*)`/g
 
 const RELATIVE = /^\.\.?\//

package/dist/integrity/slopnators/sl_undeclared_operation.js

@@ -1,5 +1,5 @@
-import { descend, read, reached } from "../../core/descend.js";
-import { rowsIn } from "./sl_unthreaded.js";
+import { descend, read, reached } from '../../core/descend.js';
+import { rowsIn } from './sl_unthreaded.js';
 const UNDER = 'operations/';
 const DISPATCH = 'dispatch';
 function declared() {
@@ -15,16 +15,111 @@ function declared() {
                 continue;
             if (one.id !== undefined)
                 found.add(one.id);
-            const named = where.split('/').at(-1)?.replace(/\.[^.]+$/, '');
-            if (named !== undefined)
-                found.add(named);
         }
     }
     return found;
 }
+function bodies() {
+    const found = new Set();
+    descend();
+    for (const at of reached()) {
+        const text = read(at);
+        if (text === undefined)
+            continue;
+        for (const one of rowsIn(text)) {
+            const where = one.at?.split('\\').join('/');
+            if (where === undefined || !where.includes(UNDER))
+                continue;
+            if (one.id !== undefined)
+                found.add(where.replace(/\.[^./]+$/, ''));
+        }
+    }
+    return found;
+}
+function declaring() {
+    const found = new Set();
+    descend();
+    for (const at of reached()) {
+        const text = read(at);
+        if (text === undefined)
+            continue;
+        for (const one of rowsIn(text)) {
+            const where = one.at?.split('\\').join('/');
+            if (where === undefined)
+                continue;
+            found.add(where.replace(/\.[^./]+$/, ''));
+        }
+    }
+    return found;
+}
+function importedFrom(name, ancestors) {
+    const program = ancestors.find((one) => one?.type === 'Program');
+    for (const one of program?.body ?? []) {
+        if (one.type !== 'ImportDeclaration' || typeof one.source?.value !== 'string')
+            continue;
+        if (!(one.specifiers ?? []).some((each) => each.local?.name === name))
+            continue;
+        return one.source.value;
+    }
+    return undefined;
+}
+function namedIn(said) {
+    if (said === undefined)
+        return undefined;
+    if (typeof said.typeName?.name === 'string')
+        return said.typeName.name;
+    const inner = namedIn(said.typeAnnotation);
+    if (inner !== undefined)
+        return inner;
+    for (const one of said.types ?? []) {
+        const found = namedIn(one);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+const typeNamed = (held) => namedIn(held?.typeAnnotation?.typeAnnotation);
+function annotating(name, ancestors) {
+    for (const held of ancestors) {
+        for (const param of held.params ?? []) {
+            if (param.type !== 'Identifier' || param.name !== name)
+                continue;
+            const said = typeNamed(param);
+            if (said !== undefined)
+                return said;
+        }
+        const body = held.body;
+        for (const one of Array.isArray(body) ? body : []) {
+            if (one.type !== 'VariableDeclaration')
+                continue;
+            for (const each of one.declarations ?? []) {
+                if (each.id?.type !== 'Identifier' || each.id.name !== name)
+                    continue;
+                const said = typeNamed(each.id);
+                if (said !== undefined)
+                    return said;
+            }
+        }
+    }
+    return undefined;
+}
+const settled = (from, source) => {
+    if (!source.startsWith('.'))
+        return source.replace(/\.[^./]+$/, '');
+    const parts = from.split('/').slice(0, -1);
+    for (const step of source.replace(/\.[^./]+$/, '').split('/')) {
+        if (step === '.' || step === '')
+            continue;
+        if (step === '..')
+            parts.pop();
+        else
+            parts.push(step);
+    }
+    return parts.join('/');
+};
 export const slopnator = {
     on: ['CallExpression'],
-    holds: (node) => {
+    holds: (node, at) => {
         const call = node;
         const callee = call?.callee;
         const named = callee?.type === 'Identifier'
@@ -39,33 +134,20 @@ export const slopnator = {
             return ('dispatch is called with nothing to dispatch, so no operation is named and none can be found — the name ' +
                 'is the whole of what makes an operation reachable');
         }
-        /*
-         * THE OPERATION ITSELF IS A BETTER ANSWER THAN ITS NAME, AND THIS USED TO REFUSE IT.
-         *
-         * This asked for a string literal and refused everything else, which was right when the only
-         * caller was a UI seam handed a bare name. It has been wrong since dispatch stopped taking one:
-         * the note above says so in as many words — "`dispatch` in packages/core/operations/src/dispatch.ts
-         * takes an Operation object rather than a name". What ships now imports the compiled operation
-         * and hands over the binding, and a binding cannot be assembled at run time: if it named nothing,
-         * the file would not compile.
-         *
-         * Measured 2026-08-31 on a registry install: an operations-only app, everything made by the CLI,
-         * failed its own sweep on `operations/_client.ts` — a file its own generator had just written,
-         * naming an operation the same tree declares. The gate refuses the build now, so a law that
-         * refuses a generated file is an app that cannot ship.
-         *
-         * Narrow on purpose. An identifier is accepted only when it IS one of the declared operations,
-         * which is the shape the generators emit — `import { operation as wf_charge }` and then
-         * `dispatch(wf_charge, …)`. A variable holding a computed name is still refused, because it does
-         * not match a declaration, and that is the hole this law was written for.
-         */
         const all = declared();
         if (first.type === 'Identifier' && typeof first.name === 'string') {
             if (all.has(first.name))
                 return false;
-            return (`dispatch is handed \`${first.name}\`, and nothing declares an operation by that name. A binding is only ` +
-                'checkable when it is the operation — import the compiled operation and hand that over, so what runs and ' +
-                'what was declared are the same thing rather than two things that agree today');
+            const source = importedFrom(first.name, at.ancestors());
+            if (source !== undefined && bodies().has(settled(at.filename, source)))
+                return false;
+            const named = annotating(first.name, at.ancestors());
+            const typed = named === undefined ? undefined : importedFrom(named, at.ancestors());
+            if (typed !== undefined && declaring().has(settled(at.filename, typed)))
+                return false;
+            return (`dispatch is handed \`${first.name}\`, and it is not imported from a file any row declares as an operation. ` +
+                'A binding is only checkable when it is the operation — import the compiled operation and hand that over, so ' +
+                'what runs and what was declared are the same thing rather than two things that agree today');
         }
         if (first.type !== 'Literal' || typeof first.value !== 'string') {
             return ('dispatch is handed a name this file does not write down, so nothing can hold it against what is declared. ' +