@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/slopnators/sl_no_dispatch_bypass.ts

@@ -3,6 +3,7 @@ import { dirname, join, normalize } from 'node:path'
 import { parser } from 'typescript-eslint'
 
 import { descend } from '../../core/descend.ts'
+import { PREFIXES } from '../../core/thread.ts'
 
 import type { Slopnator } from '../slopnator.ts'
 import { here, index, parses, unreadable } from './sl_unthreaded.ts'
@@ -11,15 +12,8 @@ const RELATIVE = /^\.\.?\//
 
 const UNDER = 'operations/'
 
-const NODES = 'nodes'
+const COMPILES = 'thread compile'
 
-/*
- * 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 INVOKER = 'dispatch'
 
 const slash = (one: string): string => one.split('\\').join('/')
@@ -34,49 +28,24 @@ interface Held {
   readonly quasis?: readonly { readonly value?: { readonly cooked?: string; readonly raw?: string } }[]
 }
 
-/* Where a name is bound, rather than used. An import is how the operation arrives. */
-const BINDS = new Set(['ImportSpecifier', 'ImportDefaultSpecifier', 'ImportNamespaceSpecifier'])
+const IMPORTED = 'ImportBinding'
 
-/*
- * 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 TYPE_ONLY = 'type'
+
+const QUERIED = 'TSTypeQuery'
 
 let bodies: ReadonlySet<string> | undefined
 
-/*
- * 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(): ReadonlySet<string> {
   if (bodies !== undefined) return bodies
-  const pass = descend()
-
-  const under = (id: string, root: string, seen: Set<string>): boolean => {
-    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<string>()
-  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())) continue
-      if (under(one.by, NODES, new Set())) continue
+      if (one.row.by !== COMPILES) continue
+      if (!prefixed.some((each) => one.by.startsWith(each))) continue
       found.add(at)
     }
   }
@@ -84,31 +53,35 @@ function operations(): ReadonlySet<string> {
   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: string): boolean {
   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))
 }
 
-const TRIED = ['', '.ts', '.tsx']
+let endings: ReadonlyMap<string, string> | undefined
+
+function spellings(): ReadonlyMap<string, string> {
+  if (endings !== undefined) return endings
+  const found = new Map<string, string>()
+  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
+}
 
 function reaches(said: string, from: string): boolean {
   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: Held | undefined, said: string[]): void {
   if (node === undefined || node === null || typeof node !== 'object') return
   if (node.type === 'Literal' && typeof node.value === 'string') said.push(node.value)
@@ -122,59 +95,43 @@ function spelled(node: Held | undefined, said: string[]): void {
   }
 }
 
-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: string, from: string): ReadonlySet<string> {
-  const found = new Set<string>()
-  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)
+interface Bound {
+  readonly type?: string
+  readonly node?: { readonly importKind?: string }
+  readonly parent?: { readonly importKind?: string; readonly source?: { readonly value?: unknown } }
+}
+
+interface Named {
+  readonly defs?: readonly Bound[]
+  readonly references?: readonly { readonly identifier?: unknown; readonly isValueReference?: boolean }[]
+}
+
+interface Scoped {
+  readonly scopes?: readonly { readonly variables?: readonly Named[] }[]
+}
+
+interface Parsed {
+  readonly ast: unknown
+  readonly scopeManager?: Scoped
+}
+
+function handled(scopes: Scoped | undefined, from: string): ReadonlySet<unknown> {
+  const found = new Set<unknown>()
+  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: unknown,
   up: Held | undefined,
@@ -211,42 +168,23 @@ export const slopnator: Slopnator = {
     if (!text.includes(UNDER)) return false
 
     const from = dirname(path)
-    const mine = bound(text, from)
 
-    let ast: unknown
+    let parsed: Parsed
     try {
-      ast = (parser.parseForESLint as (t: string, o: unknown) => { ast: unknown })(text, {
+      parsed = (parser.parseForESLint as (t: string, o: unknown) => Parsed)(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.
-     */
+    const mine = handled(parsed.scopeManager, from)
+
     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.
-         */
+      walked(parsed.ast, undefined, (held, parent) => {
         const dynamic =
           held.type === 'ImportExpression'
             ? held.source
@@ -266,9 +204,8 @@ export const slopnator: Slopnator = {
           }
         }
 
-        if (held.type !== 'Identifier' || typeof held.name !== 'string' || !mine.has(held.name)) return undefined
-        const up = parent?.type ?? ''
-        if (BINDS.has(up) || TYPED.has(up)) return undefined
+        if (held.type !== 'Identifier' || typeof held.name !== 'string' || !mine.has(held)) return undefined
+        if (parent?.type === QUERIED) return undefined
         if (
           parent?.type === 'CallExpression' &&
           parent.callee?.type === 'Identifier' &&
@@ -286,23 +223,10 @@ export const slopnator: Slopnator = {
       }) ?? 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)",
@@ -317,10 +241,34 @@ export const slopnator: 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",
     ],

package/dist/integrity/slopnators/sl_no_import_cycle.js

@@ -1,12 +1,16 @@
-import { existsSync, readFileSync } from "../../core/files.js";
+import { existsSync, readFileSync } from '../../integrations/disk.js';
 import { dirname, resolve } from 'node:path';
-import { findTree } from "../../core/tree.js";
+import { findTree } from '../../core/tree.js';
 const ROOT = findTree().at;
-const IMPORTS = /(?:^|\n)\s*import\s[^'"]*['"]([^'"]+)['"]/g;
+const IMPORTS = /(?:^|\n)\s*import\s+(?!type\s)[^'"]*['"]([^'"]+)['"]/g;
 const target = (from, spec) => spec.startsWith('.') ? resolve(dirname(from), spec) : undefined;
+const erased = (node) => node.importKind === 'type' ||
+    ((node.specifiers ?? []).length > 0 && (node.specifiers ?? []).every((one) => one.importKind === 'type'));
 export const slopnator = {
     on: ['ImportDeclaration'],
     holds: (node, at) => {
+        if (erased(node))
+            return false;
         const spec = node.source?.value;
         if (typeof spec !== 'string')
             return false;
@@ -34,9 +38,16 @@ export const slopnator = {
         right: [
             "import type { Law } from '../../core/generators/meta.ts'",
             "import { SLUG, type Shaped } from '../../core/types.ts'",
-            "import { existsSync } from 'node:fs'",
+            "import { join } from 'node:path'",
             "import type { Rule } from 'eslint'",
             "import { CONSTRAINTS } from '../constraint.ts'",
+            {
+                files: [
+                    { at: 'threads/_probe_three.ts', source: "import type { Four } from './_probe_four.ts'\nexport const three: Four = 1\n" },
+                    { at: 'threads/_probe_four.ts', source: "import { three } from './_probe_three.ts'\nexport type Four = number\nexport const four = three\n" },
+                ],
+                at: 'threads/_probe_three.ts',
+            },
         ],
     },
 };

package/dist/integrity/slopnators/sl_no_import_cycle.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync } from '../../integrations/disk.ts'
 import { dirname, resolve } from 'node:path'
 
 import type { Slopnator } from '../slopnator.ts'
@@ -6,16 +6,25 @@ import { findTree } from '../../core/tree.ts'
 
 const ROOT = findTree().at
 
-const IMPORTS = /(?:^|\n)\s*import\s[^'"]*['"]([^'"]+)['"]/g
+const IMPORTS = /(?:^|\n)\s*import\s+(?!type\s)[^'"]*['"]([^'"]+)['"]/g
 
-type Node = { source?: { value?: unknown } }
+type Node = {
+  source?: { value?: unknown }
+  importKind?: string
+  specifiers?: readonly { importKind?: string }[]
+}
 
 const target = (from: string, spec: string): string | undefined =>
   spec.startsWith('.') ? resolve(dirname(from), spec) : undefined
 
+const erased = (node: Node): boolean =>
+  node.importKind === 'type' ||
+  ((node.specifiers ?? []).length > 0 && (node.specifiers ?? []).every((one) => one.importKind === 'type'))
+
 export const slopnator: Slopnator = {
   on: ['ImportDeclaration'],
   holds: (node, at) => {
+    if (erased(node as Node)) return false
     const spec = (node as Node).source?.value
     if (typeof spec !== 'string') return false
 
@@ -42,9 +51,16 @@ export const slopnator: Slopnator = {
     right: [
       "import type { Law } from '../../core/generators/meta.ts'",
       "import { SLUG, type Shaped } from '../../core/types.ts'",
-      "import { existsSync } from 'node:fs'",
+      "import { join } from 'node:path'",
       "import type { Rule } from 'eslint'",
       "import { CONSTRAINTS } from '../constraint.ts'",
+      {
+        files: [
+          { at: 'threads/_probe_three.ts', source: "import type { Four } from './_probe_four.ts'\nexport const three: Four = 1\n" },
+          { at: 'threads/_probe_four.ts', source: "import { three } from './_probe_three.ts'\nexport type Four = number\nexport const four = three\n" },
+        ],
+        at: 'threads/_probe_three.ts',
+      },
     ],
   },
 }

package/dist/integrity/slopnators/sl_no_such_command.js

@@ -1,6 +1,6 @@
-import { readFileSync } from "../../core/files.js";
+import { readFileSync } from '../../integrations/disk.js';
 import { resolve } from 'node:path';
-import { findTree } from "../../core/tree.js";
+import { findTree } from '../../core/tree.js';
 const ROOT = findTree().at;
 const keyOf = (property) => {
     if (property.computed === true)

package/dist/integrity/slopnators/sl_no_such_command.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from '../../core/files.ts'
+import { readFileSync } from '../../integrations/disk.ts'
 import { resolve } from 'node:path'
 
 import type { Sourced } from '../constraint.ts'

package/dist/integrity/slopnators/sl_outside_an_operation.js

@@ -0,0 +1,20 @@
+import { HANDED_TO, judging } from './sl_undeclared_crossing.js';
+const SAYS = 'Each of these uses what this app hands an operation, and an operation is the only thing handed one.';
+export const slopnator = {
+    holds: (_node, at) => judging(at, HANDED_TO, SAYS),
+    proves: {
+        wrong: [
+            {
+                files: [
+                    { at: 'thread/operations/operations.ts', source: 'export interface Store {\n  insert(row: unknown): Promise<void>\n}\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Store }\n' },
+                    { at: 'threads/_probe_reach.ts', source: "import type { Store } from '../thread/operations/operations.ts'\n\nexport const seeded = async (kept: Store): Promise<void> => {\n  await kept['insert']({})\n}\n" },
+                ],
+                at: 'threads/_probe_reach.ts',
+            },
+        ],
+        right: [
+            'export const began = Date.now()',
+            "import { join } from 'node:path'\n\nexport const at = join('a', 'b')",
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_outside_an_operation.ts

@@ -0,0 +1,25 @@
+import type { Slopnator } from '../slopnator.ts'
+
+import { HANDED_TO, judging } from './sl_undeclared_crossing.ts'
+
+const SAYS =
+  'Each of these uses what this app hands an operation, and an operation is the only thing handed one.'
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => judging(at, HANDED_TO, SAYS),
+  proves: {
+    wrong: [
+      {
+        files: [
+          { at: 'thread/operations/operations.ts', source: 'export interface Store {\n  insert(row: unknown): Promise<void>\n}\n\nexport type Opened<R extends string = never> = { readonly [K in R]: Store }\n' },
+          { at: 'threads/_probe_reach.ts', source: "import type { Store } from '../thread/operations/operations.ts'\n\nexport const seeded = async (kept: Store): Promise<void> => {\n  await kept['insert']({})\n}\n" },
+        ],
+        at: 'threads/_probe_reach.ts',
+      },
+    ],
+    right: [
+      'export const began = Date.now()',
+      "import { join } from 'node:path'\n\nexport const at = join('a', 'b')",
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_screen_holds_only_declared.d.ts

@@ -0,0 +1,2 @@
+import type { Slopnator } from '../slopnator.ts';
+export declare const slopnator: Slopnator;

package/dist/integrity/slopnators/sl_screen_holds_only_declared.js

@@ -0,0 +1,61 @@
+import { descend, read, reached } from '../../core/descend.js';
+import { rowsIn } from './sl_unthreaded.js';
+const WRAPS = 'screen';
+const HANDS = 'dispatch';
+const ELEMENT = 'element';
+const COMPOSITION = 'composition';
+const nameOf = (id) => id.split('-').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('');
+function declared() {
+    const found = new Set();
+    descend();
+    for (const at of reached()) {
+        const text = read(at);
+        if (text === undefined)
+            continue;
+        let waiting = [];
+        for (const one of rowsIn(text)) {
+            if (one.id === undefined)
+                continue;
+            if (one.list === 'declares') {
+                waiting.push(one.id);
+                continue;
+            }
+            if (one.list !== undefined)
+                continue;
+            if (one.id === ELEMENT || one.id === COMPOSITION)
+                for (const id of waiting)
+                    found.add(nameOf(id));
+            waiting = [];
+        }
+    }
+    return found;
+}
+export const slopnator = {
+    on: ['CallExpression'],
+    holds: (node) => {
+        const held = node;
+        const called = held.callee?.type === 'Identifier' ? held.callee.name : undefined;
+        if (called === undefined)
+            return false;
+        if (called === WRAPS || called === HANDS)
+            return false;
+        if (declared().has(called))
+            return false;
+        return (called + ' is called here, and a screen is made of declared elements and compositions and may hand an operation to ' +
+            HANDS + '. Nothing else has a place in one, so this is work that belongs in an operation');
+    },
+    proves: {
+        wrong: ["export const Orders = screen('orders', {}, () => loadOrders())"],
+        right: [
+            {
+                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_list_orders',\n      describes: 'lists the orders',\n      derives: [\n        {\n          id: 'wf_list_orders_body',\n          at: 'operations/wf_list_orders.ts',\n          by: 'thread compile',\n        },\n      ],\n    },\n  ],\n}\n" },
+                    { at: 'screens/probe.tsx', source: "import { dispatch } from '../operations/_dispatch.ts'\n\nimport { operation } from '../operations/wf_list_orders.ts'\n\nexport const Orders = screen('orders', {}, () => dispatch(operation, input, actor, opened))\n" },
+                ],
+                at: 'screens/probe.tsx',
+            },
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_screen_holds_only_declared.ts

@@ -0,0 +1,70 @@
+import type { Slopnator } from '../slopnator.ts'
+
+import { descend, read, reached } from '../../core/descend.ts'
+import { rowsIn } from './sl_unthreaded.ts'
+
+const WRAPS = 'screen'
+
+const HANDS = 'dispatch'
+
+const ELEMENT = 'element'
+
+const COMPOSITION = 'composition'
+
+const nameOf = (id: string): string =>
+  id.split('-').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')
+
+function declared(): ReadonlySet<string> {
+  const found = new Set<string>()
+
+  descend()
+
+  for (const at of reached()) {
+    const text = read(at)
+    if (text === undefined) continue
+
+    let waiting: string[] = []
+    for (const one of rowsIn(text)) {
+      if (one.id === undefined) continue
+      if (one.list === 'declares') {
+        waiting.push(one.id)
+        continue
+      }
+      if (one.list !== undefined) continue
+      if (one.id === ELEMENT || one.id === COMPOSITION) for (const id of waiting) found.add(nameOf(id))
+      waiting = []
+    }
+  }
+
+  return found
+}
+
+export const slopnator: Slopnator = {
+  on: ['CallExpression'],
+  holds: (node) => {
+    const held = node as { readonly callee?: { readonly type?: string; readonly name?: string } }
+    const called = held.callee?.type === 'Identifier' ? held.callee.name : undefined
+    if (called === undefined) return false
+    if (called === WRAPS || called === HANDS) return false
+    if (declared().has(called)) return false
+
+    return (
+      called + ' is called here, and a screen is made of declared elements and compositions and may hand an operation to ' +
+      HANDS + '. Nothing else has a place in one, so this is work that belongs in an operation'
+    )
+  },
+  proves: {
+    wrong: ["export const Orders = screen('orders', {}, () => loadOrders())"],
+    right: [
+      {
+        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_list_orders',\n      describes: 'lists the orders',\n      derives: [\n        {\n          id: 'wf_list_orders_body',\n          at: 'operations/wf_list_orders.ts',\n          by: 'thread compile',\n        },\n      ],\n    },\n  ],\n}\n" },
+          { at: 'screens/probe.tsx', source: "import { dispatch } from '../operations/_dispatch.ts'\n\nimport { operation } from '../operations/wf_list_orders.ts'\n\nexport const Orders = screen('orders', {}, () => dispatch(operation, input, actor, opened))\n" },
+        ],
+        at: 'screens/probe.tsx',
+      },
+    ],
+  },
+}