@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/slopnators/sl_no_child_process.ts

@@ -1,6 +1,31 @@
+import { dirname, join, normalize } from 'node:path'
+
 import type { Slopnator } from '../slopnator.ts'
 
-const STARTS_A_PROCESS = new Set(['node:child_process', 'child_process'])
+import { ROOT, descend, read, reached } from '../../core/descend.ts'
+import { rowsIn } from './sl_unthreaded.ts'
+
+const DOOR = 'programs'
+
+const ROOTED = ROOT + '/'
+
+const slash = (one: string): string => one.split('\\').join('/')
+
+const bare = (one: string): string => one.replace(/\.[^./]+$/, '')
+
+function doorway(): string | undefined {
+  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
+}
 
 interface Node {
   readonly type?: string
@@ -16,7 +41,7 @@ const named = (held: unknown): string | undefined => {
 
 export const slopnator: Slopnator = {
   on: ['ImportDeclaration', 'ImportExpression', 'CallExpression'],
-  holds: (node) => {
+  holds: (node, at) => {
     const held = node as Node
     const from =
       held.type === 'ImportDeclaration' || held.type === 'ImportExpression'
@@ -25,27 +50,28 @@ export const slopnator: Slopnator = {
           ? named(held.arguments?.[0])
           : undefined
 
-    if (from === undefined || !STARTS_A_PROCESS.has(from)) return false
+    if (from === undefined) return false
+
+    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 \`${from}\`, so this slopnator can start a process — and whatever it starts can reach back into the enforcement that called it`
+    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',
       },
@@ -55,7 +81,7 @@ export const slopnator: 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',

package/dist/integrity/slopnators/sl_no_dispatch_bypass.js

@@ -1,62 +1,29 @@
 import { dirname, join, normalize } from 'node:path';
 import { parser } from 'typescript-eslint';
-import { descend } from "../../core/descend.js";
-import { here, index, parses, unreadable } from "./sl_unthreaded.js";
+import { descend } from '../../core/descend.js';
+import { PREFIXES } from '../../core/thread.js';
+import { here, index, parses, unreadable } from './sl_unthreaded.js';
 const RELATIVE = /^\.\.?\//;
 const UNDER = 'operations/';
-const NODES = 'nodes';
-/*
- * The one thing an operation may be handed to.
- *
- * It is still `dispatch` and it is still the only one. What moved 2026-08-28 is where it lives:
- * it was imported from this framework, and it is now the app's own `operations/_dispatch.ts`,
- * written by `thread compile`. The name a caller writes did not change, so neither did this.
- */
+const COMPILES = 'thread compile';
 const INVOKER = 'dispatch';
 const slash = (one) => one.split('\\').join('/');
-/* Where a name is bound, rather than used. An import is how the operation arrives. */
-const BINDS = new Set(['ImportSpecifier', 'ImportDefaultSpecifier', 'ImportNamespaceSpecifier']);
-/*
- * Where a name is a shape, not a thing.
- *
- * `const one: typeof operation` runs nothing and reaches nothing — it borrows the type and is erased
- * before anything executes. Refusing it was a false positive found by reading, not by running: the
- * probe written to test the reassignment form used exactly this line to type its own variable, and
- * the law would have refused the probe for its type annotation rather than for the bypass under it.
- */
-const TYPED = new Set(['TSTypeQuery', 'TSTypeReference', 'TSQualifiedName', 'TSImportType']);
+const IMPORTED = 'ImportBinding';
+const TYPE_ONLY = 'type';
+const QUERIED = 'TSTypeQuery';
 let bodies;
-/*
- * Which files are operation bodies, asked of the tree rather than guessed from a directory.
- *
- * An operation body is a file a row beneath `operations` DERIVES and that is not a node's body, and
- * the descent already knows every one of them. Reading the directory instead was close enough while
- * an operation was the only thing living there — and stopped being close enough the moment an
- * operation was folded into a body plus the steps it is woven from: the woven body imports its own
- * steps, the steps sat under `operations/`, and this law refused the one file it exists to protect
- * for importing the one file it is made of. A rule that refuses the sanctioned form is deciding
- * nothing, which is the same failure this law was rewritten for on 2026-08-25.
- */
 function operations() {
     if (bodies !== undefined)
         return bodies;
-    const pass = descend();
-    const under = (id, root, seen) => {
-        if (id === root)
-            return true;
-        if (seen.has(id))
-            return false;
-        seen.add(id);
-        return (pass.coined.get(id)?.from ?? []).some((one) => under(one, root, seen));
-    };
+    const prefixed = Object.values(PREFIXES);
     const found = new Set();
-    for (const [at, threadings] of pass.threaded) {
+    for (const [at, threadings] of descend().threaded) {
         for (const one of threadings) {
             if (one.list !== 'derives')
                 continue;
-            if (!under(one.by, 'operations', new Set()))
+            if (one.row.by !== COMPILES)
                 continue;
-            if (under(one.by, NODES, new Set()))
+            if (!prefixed.some((each) => one.by.startsWith(each)))
                 continue;
             found.add(at);
         }
@@ -64,31 +31,37 @@ function operations() {
     bodies = found;
     return found;
 }
-/*
- * Whether a path is an operation body.
- *
- * The tree decides for every file the tree reaches. For a file it does not reach — a probe, a
- * scratch file, anything not yet declared — the shape decides: an operation is seeded as one file
- * directly inside `operations/`, so a single segment is a body and a deeper path is something an
- * operation is built from. Nothing the tree does not reach can be part of an app anyway; that
- * fallback is what makes this law's own proofs mean the same thing in every repository.
- */
 function isBody(path) {
     const known = index().reached;
     if (known.has(path))
         return operations().has(path);
     if (!path.startsWith(UNDER))
         return false;
-    return !path.slice(UNDER.length).includes('/');
+    const file = path.slice(UNDER.length);
+    return !file.includes('/') && Object.values(PREFIXES).some((one) => file.startsWith(one));
+}
+let endings;
+function spellings() {
+    if (endings !== undefined)
+        return endings;
+    const found = new Map();
+    for (const one of index().reached) {
+        const dot = one.lastIndexOf('.');
+        if (dot > one.lastIndexOf('/'))
+            found.set(one.slice(0, dot), one);
+    }
+    endings = found;
+    return found;
 }
-const TRIED = ['', '.ts', '.tsx'];
 function reaches(said, from) {
     if (said === '')
         return false;
     const at = slash(normalize(RELATIVE.test(said) ? join(from, said) : said));
-    return TRIED.some((one) => isBody(`${at}${one}`));
+    if (isBody(at))
+        return true;
+    const whole = spellings().get(at);
+    return whole !== undefined && isBody(whole);
 }
-/* Whatever a run-time reach spells out, whole or in pieces. */
 function spelled(node, said) {
     if (node === undefined || node === null || typeof node !== 'object')
         return;
@@ -107,58 +80,26 @@ function spelled(node, said) {
             spelled(value, said);
     }
 }
-const IMPORTS = /import\s+((?:type\s+)?[^'"]*?)\s+from\s+['"]([^'"]+)['"]/g;
-const LOCAL = /(?:^|[,{]|\s)(?:[A-Za-z_$][\w$]*\s+as\s+)?([A-Za-z_$][\w$]*)/g;
-/*
- * `dispatch` IS NOT AN OPERATION, AND IT LIVES WHERE THE OPERATIONS LIVE.
- *
- * `bound` below calls every name imported from under the operations directory an operation, which is
- * right for every file there but one: an app's own dispatch is written to `operations/_dispatch.ts`,
- * so a file importing `dispatch` from beside its operations had `dispatch` itself added to the set —
- * and then this law refused that file for doing something with an operation other than handing it to
- * dispatch. The thing it was accused of mishandling was the handler.
- *
- * It had never surfaced because nothing imported dispatch from inside that directory. Measured
- * 2026-08-30, when the generated client gained a binding that calls the app's own dispatch for an
- * operation needing no server, and the app refused a file its own generator had just written.
- *
- * The other three below are not names at all — they are the words of an import clause that the
- * regex cannot tell from an identifier. This one is a real binding that is really imported and
- * really is not an operation, which is the same answer for a different reason.
- */
-const NOT_A_NAME = new Set(['type', 'as', 'from', 'import', 'dispatch']);
-/*
- * The names this file bound by importing an operation body.
- *
- * A type-only import binds nothing that can be run and is skipped: `import type { Operation }` names
- * a shape, and a shape cannot be dispatched or reached past.
- */
-function bound(text, from) {
+function handled(scopes, from) {
     const found = new Set();
-    for (const one of text.matchAll(IMPORTS)) {
-        const clause = one[1] ?? '';
-        if (/^type\s/.test(clause))
-            continue;
-        if (!reaches(one[2] ?? '', from))
-            continue;
-        for (const name of clause.matchAll(LOCAL)) {
-            const held = name[1];
-            if (held !== undefined && !NOT_A_NAME.has(held))
-                found.add(held);
+    for (const scope of scopes?.scopes ?? []) {
+        for (const one of scope.variables ?? []) {
+            const made = (one.defs ?? [])[0];
+            if (made?.type !== IMPORTED)
+                continue;
+            if (made.node?.importKind === TYPE_ONLY || made.parent?.importKind === TYPE_ONLY)
+                continue;
+            const said = made.parent?.source?.value;
+            if (typeof said !== 'string' || !reaches(said, from))
+                continue;
+            for (const seen of one.references ?? []) {
+                if (seen.isValueReference !== false && seen.identifier !== undefined)
+                    found.add(seen.identifier);
+            }
         }
     }
     return found;
 }
-/*
- * Parsed here rather than taken from the visitor.
- *
- * `holds` is handed a node when a law runs as an eslint rule and nothing at all when the sweep runs
- * it over a file — measured 2026-08-25, the sweep calls it once per file with `node` undefined, so a
- * reading that only inspected what it was given threw on the first file it saw. What a file DOES
- * with a binding is a question about the whole file anyway, not about one node in it.
- *
- * The parent comes down with the node because the whole rule is about where a name appears.
- */
 function walked(node, up, seen) {
     if (node === null || typeof node !== 'object')
         return undefined;
@@ -195,40 +136,20 @@ export const slopnator = {
         if (!text.includes(UNDER))
             return false;
         const from = dirname(path);
-        const mine = bound(text, from);
-        let ast;
+        let parsed;
         try {
-            ast = parser.parseForESLint(text, {
+            parsed = parser.parseForESLint(text, {
                 range: true,
                 ecmaVersion: 'latest',
                 sourceType: 'module',
                 ecmaFeatures: { jsx: true },
-            }).ast;
+            });
         }
         catch {
             return false;
         }
-        /*
-         * One rule, stated once.
-         *
-         * The first reading of this enumerated the SHAPES of a bypass — a member access, a call, an
-         * argument — and every shape it did not think of walked through: an alias, a destructure, an
-         * array holding the name, a comma operator. Enumerating forms is how a refusal ends up with a
-         * list of everything somebody happened to try. The rule is not a list. An operation goes to
-         * `dispatch` and nowhere else, so the name may appear where it is bound and as an argument to
-         * `dispatch`, and every other appearance is the finding — whatever it happens to look like.
-         */
-        return (walked(ast, undefined, (held, parent) => {
-            /*
-             * A body reached at run time never binds a name at all, so the rule above cannot see it.
-             *
-             * What is read is everything the reach spells out, whole or in pieces: a plain literal, a
-             * concatenation, a template. Measured 2026-08-26 against the reading this replaces, which
-             * only ever inspected a plain `Literal` — `await import('../operations/' + name + '.ts')`
-             * passed it without a word, which is the exact form its own comment said it was written to
-             * catch. Nothing legitimate needs any of it: dispatch is handed the operation, and the one
-             * file that hands it over imports it statically.
-             */
+        const mine = handled(parsed.scopeManager, from);
+        return (walked(parsed.ast, undefined, (held, parent) => {
             const dynamic = held.type === 'ImportExpression'
                 ? held.source
                 : held.type === 'CallExpression' && held.callee?.type === 'Identifier' && held.callee.name === 'require'
@@ -243,10 +164,9 @@ export const slopnator = {
                         `to \`${INVOKER}\`, and a file that goes looking for one is looking for a second way in`);
                 }
             }
-            if (held.type !== 'Identifier' || typeof held.name !== 'string' || !mine.has(held.name))
+            if (held.type !== 'Identifier' || typeof held.name !== 'string' || !mine.has(held))
                 return undefined;
-            const up = parent?.type ?? '';
-            if (BINDS.has(up) || TYPED.has(up))
+            if (parent?.type === QUERIED)
                 return undefined;
             if (parent?.type === 'CallExpression' &&
                 parent.callee?.type === 'Identifier' &&
@@ -259,23 +179,10 @@ export const slopnator = {
                 'aliasing it, taking it apart or passing it on all reach past every one of them');
         }) ?? false);
     },
-    /*
-     * These were driven at `holds` directly, because the trial harness cannot run them.
-     *
-     * A shipped law is meant to be proved by `thread trials`, and today nothing proves one anywhere:
-     * the harness cannot run in this repository at all — the framework has no tree, and the command
-     * that once tried was removed in 6e98a6d after it was measured exiting 1 — and in an app
-     * `thread trials` answers "0 trials from the 0 rule(s) this tree declares",
-     * because a shipped constraint is proved in the package that ships it. So every proof below was
-     * written to a real probe file and handed to `slopnator.holds` by hand, 2026-08-26: fourteen
-     * refused, six accepted, no failures. That is a stand-in for the harness and it is written down
-     * here rather than only in a report, because a proof nobody can run is indistinguishable from a
-     * proof that passes, and the next person to read this list deserves to know which one it is.
-     */
     proves: {
         wrong: [
             "import { operation } from './operations/wf_send_invoice.ts'\n\nawait operation.run(input)",
-            "import { operation } from './operations/wf_send_invoice.ts'\n\nconst { run } = operation\n\nawait run(hands, held)",
+            "import { operation } from './operations/wf_send_invoice.ts'\n\nconst { run } = operation\n\nawait run(opened, held)",
             "import { operation } from './operations/wf_send_invoice.ts'\n\nawait operation(input)",
             "import { operation } from './operations/wf_send_invoice.ts'\n\nawait somewhere(operation, input)",
             "import { operation } from './operations/wf_send_invoice.ts'\n\nconst one = operation\n\nawait one.run(input)",
@@ -290,10 +197,34 @@ export const slopnator = {
             'const held = await import(`../operations/${name}.ts`)',
         ],
         right: [
-            "import { dispatch } from './operations/_dispatch.ts'\n\nimport { operation } from './operations/wf_send_invoice.ts'\n\nawait dispatch(operation, input, actor, seams)",
+            {
+                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_operations.ts',\n    },\n  ],\n}\n" },
+                    { at: 'threads/_probe_operations.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      describes: 'sends an invoice',\n      derives: [\n        {\n          id: 'wf_send_invoice_body',\n          at: 'operations/wf_send_invoice.ts',\n          by: 'thread compile',\n        },\n      ],\n    },\n  ],\n}\n" },
+                    { at: 'probe.tsx', source: "import { dispatch } from './operations/_dispatch.ts'\n\nimport { operation } from './operations/wf_send_invoice.ts'\n\nawait dispatch(operation, input, actor, opened)\n" },
+                ],
+                at: 'probe.tsx',
+            },
             "import type { Operation } from '../../operations/operations.ts'\n\nexport const held: Operation = one",
-            "import { dispatch } from './operations/_dispatch.ts'\n\nawait dispatch(one, input, actor, seams)",
-            "import { dispatch } from './operations/_dispatch.ts'\n\nimport { operation } from './operations/wf_send_invoice.ts'\n\nlet one: typeof operation\n\nawait dispatch(operation, input, actor, seams)",
+            {
+                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_operations.ts',\n    },\n  ],\n}\n" },
+                    { at: 'threads/_probe_operations.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      describes: 'sends an invoice',\n      derives: [\n        {\n          id: 'wf_send_invoice_body',\n          at: 'operations/wf_send_invoice.ts',\n          by: 'thread compile',\n        },\n      ],\n    },\n  ],\n}\n" },
+                    { at: 'probe.tsx', source: "import { dispatch } from './operations/_dispatch.ts'\n\nawait dispatch(wf_send_invoice_body, input, actor, opened)\n" },
+                ],
+                at: 'probe.tsx',
+            },
+            {
+                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_operations.ts',\n    },\n  ],\n}\n" },
+                    { at: 'threads/_probe_operations.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      describes: 'sends an invoice',\n      derives: [\n        {\n          id: 'wf_send_invoice_body',\n          at: 'operations/wf_send_invoice.ts',\n          by: 'thread compile',\n        },\n      ],\n    },\n  ],\n}\n" },
+                    { at: 'probe.tsx', source: "import { dispatch } from './operations/_dispatch.ts'\n\nimport { operation } from './operations/wf_send_invoice.ts'\n\nlet one: typeof operation\n\nawait dispatch(operation, input, actor, opened)\n" },
+                ],
+                at: 'probe.tsx',
+            },
             "import * as steps from './operations/wf_send_invoice/steps.ts'\n\nexport const held = steps.reads_the_invoice",
             "import * as steps from './steps/wf_send_invoice.ts'\n\nexport const held = steps.reads_the_invoice",
         ],