@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/slopnators/sl_missing_row.ts

@@ -1,140 +0,0 @@
-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'
-
-const NODE = /export\s+const\s+[A-Za-z_$][\w$]*\s*:\s*Threaded\b/
-
-const SHAPES = [/declares:\s*\[/g, /export\s+const\s+declares\b[^\n]*?=\s*\[/g]
-
-const ID = /\bid:\s*'([^']+)'/g
-const CALLED = /(?:^|[\s,[(])[a-zA-Z_$][\w$]*\(\s*'([^']+)'/g
-
-const QUOTED = /"(?:[^"\\\n]|\\.)*"|`(?:[^`\\]|\\.)*`/g
-
-function closes(code: string, from: number): number {
-  let depth = 0
-  for (let at = from; at < code.length; at += 1) {
-    if (code[at] === '[') depth += 1
-    else if (code[at] === ']') {
-      depth -= 1
-      if (depth === 0) return at
-    }
-  }
-  return -1
-}
-
-function shippedIn(text: string): ReadonlySet<string> {
-  const code = text.replace(QUOTED, '""')
-  if (!NODE.test(code)) return new Set()
-  const found = new Set<string>()
-  for (const shape of SHAPES) {
-    for (const one of code.matchAll(shape)) {
-      const opens = (one.index ?? 0) + one[0].length - 1
-      const shut = closes(code, opens)
-      if (shut === -1) continue
-      const rows = code.slice(opens, shut)
-      for (const held of rows.matchAll(ID)) found.add(held[1] ?? '')
-      for (const held of rows.matchAll(CALLED)) found.add(held[1] ?? '')
-    }
-  }
-  return found
-}
-
-function heldIn(text: string): ReadonlySet<string> {
-  const code = text.replace(QUOTED, '""')
-  const found = new Set<string>()
-  for (const one of code.matchAll(ID)) found.add(one[1] ?? '')
-  for (const one of code.matchAll(CALLED)) found.add(one[1] ?? '')
-  return found
-}
-
-function filesIn(dir: string): readonly string[] {
-  try {
-    return readdirSync(dir).filter((one) => one.endsWith('.ts')).map((one) => join(dir, one))
-  } catch {
-    return []
-  }
-}
-
-function installed(root: string): readonly { readonly name: string; readonly src: string }[] {
-  const at = join(root, 'node_modules', ORGANISATION)
-  const found: { name: string; src: string }[] = []
-  for (const one of safely(at)) {
-    const name = `${ORGANISATION}/${one}`
-    if (!ours(name)) continue
-    const src = join(at, one, 'dist')
-    if (existsSync(src) && statSync(src).isDirectory()) found.push({ name, src })
-  }
-  return found
-}
-
-function safely(dir: string): readonly string[] {
-  try {
-    return readdirSync(dir)
-  } catch {
-    return []
-  }
-}
-
-function read(path: string): string {
-  try {
-    return readFileSync(path, 'utf8')
-  } catch {
-    return ''
-  }
-}
-
-export const slopnator: Slopnator = {
-  checks: (root) => {
-    const tree = findTree(root)
-
-    const held = new Set<string>()
-    for (const path of filesIn(tree.dir)) for (const one of heldIn(read(path))) held.add(one)
-
-    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] ?? '')
-    }
-
-    const found: string[] = []
-    for (const pkg of installed(root)) {
-      if (!wired.has(pkg.name)) continue
-      for (const path of filesIn(pkg.src)) {
-        const shipped = shippedIn(read(path))
-        if (shipped.size === 0) continue
-        for (const id of [...shipped].sort()) {
-          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`,
-          )
-        }
-      }
-    }
-    return found
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: '_threads/_probe_missing.ts', source: "import type { Threaded } from '../../core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\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',
-      },
-    ],
-    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_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.ts

@@ -1,48 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-import { here } from './sl_unthreaded.ts'
-
-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"
-
-function reExportsOnly(text: string): boolean {
-  const lines = text
-    .split('\n')
-    .map((one) => one.trim())
-    .filter((one) => one !== '')
-
-  if (lines.length === 0) return false
-  return lines.every((one) => one.startsWith('export *') || one.startsWith('export {') || one.startsWith('}') || one.startsWith('} from') || /^[A-Za-z_$][\w$]*,?$/.test(one) || /^type [A-Za-z_$][\w$]*,?$/.test(one))
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-    if (!CODE.test(path)) return false
-
-    if (BARREL_NAME.test(path)) {
-      return `${SAYS} — this file is named for the folder it sits in, so it exists to list what the folder holds, and the tree already says that`
-    }
-
-    if (reExportsOnly(at.text)) {
-      return `${SAYS} — every line of this file is a re-export, so it holds no thing of its own and names nothing the tree has not already named`
-    }
-
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [{ at: 'packages/_probe_barrel/index.ts', source: "export const held = 1\n" }],
-        at: 'packages/_probe_barrel/index.ts',
-      },
-    ],
-    right: [
-      {
-        files: [{ at: 'packages/_probe_barrel/held.ts', source: "export const held = 1\n" }],
-        at: 'packages/_probe_barrel/held.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_no_child_process.ts

@@ -1,100 +0,0 @@
-import { dirname, join, normalize } from 'node:path'
-
-import type { Slopnator } from '../slopnator.ts'
-
-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
-  readonly source?: { readonly type?: string; readonly value?: unknown }
-  readonly callee?: { readonly type?: string; readonly name?: string }
-  readonly arguments?: readonly { readonly type?: string; readonly value?: unknown }[]
-}
-
-const named = (held: unknown): string | undefined => {
-  const one = held as { type?: string; value?: unknown } | undefined
-  return one?.type === 'Literal' && typeof one.value === 'string' ? one.value : undefined
-}
-
-export const slopnator: Slopnator = {
-  on: ['ImportDeclaration', 'ImportExpression', 'CallExpression'],
-  holds: (node, at) => {
-    const held = node as 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) 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 ' + 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/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',
-      },
-    ],
-    right: [
-      {
-        files: [
-          {
-            at: 'thread/integrity/slopnators/sl_probe_spawn.ts',
-            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',
-      },
-      {
-        files: [
-          {
-            at: 'thread/integrity/slopnators/sl_probe_spawn.ts',
-            source: "export const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
-          },
-        ],
-        at: 'thread/integrity/slopnators/sl_probe_spawn.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_no_comment.ts

@@ -1,43 +0,0 @@
-import type { Slopnator, Spoken } from '../slopnator.ts'
-
-const shebang = (text: string): string | undefined => (text.startsWith('#!') ? text.slice(2, text.indexOf('\n')) : undefined)
-
-const spoken = (text: string, all: readonly Spoken[]): readonly Spoken[] => {
-  const line = shebang(text)
-  return all.filter((one, index) => !(index === 0 && one.value === line))
-}
-
-export const slopnator: Slopnator = {
-  on: ['Program'],
-  holds: (_node, at) => {
-    const all = spoken(at.text, at.comments())
-    if (all.length === 0) return false
-    const first = (all[0]?.value ?? '')
-      .split('\n')
-      .map((line) => line.trim().replace(/^\*+\s?/, ''))
-      .find((line) => line !== '') ?? ''
-    return `${String(all.length)} comment(s), the first saying "${first.slice(0, 60)}"`
-  },
-  fixes: (_node, at) => {
-    const all = spoken(at.text, at.comments())
-    if (all.length === 0) return undefined
-    let out = at.text
-    for (const one of [...all].sort((a, b) => b.range[0] - a.range[0])) {
-      out = out.slice(0, one.range[0]) + out.slice(one.range[1])
-    }
-    return out.replace(/[ \t]+$/gm, '').replace(/\n{3,}/g, '\n\n')
-  },
-  proves: {
-    wrong: [
-      'const a = 1 // a line comment',
-      '/* a block comment */\nconst a = 1',
-      '/** JSDoc on the export */\nexport const a = 1',
-    ],
-    right: [
-      'const a = "// not a comment"',
-      'const url = "https://example.com/docs"',
-      'const a = 1',
-      '#!/usr/bin/env node\nconst a = 1',
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_no_dispatch_bypass.ts

@@ -1,276 +0,0 @@
-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'
-
-const RELATIVE = /^\.\.?\//
-
-const UNDER = 'operations/'
-
-const COMPILES = 'thread compile'
-
-const INVOKER = 'dispatch'
-
-const slash = (one: string): string => one.split('\\').join('/')
-
-interface Held {
-  readonly type?: string
-  readonly name?: string
-  readonly value?: unknown
-  readonly callee?: Held
-  readonly source?: Held
-  readonly arguments?: readonly Held[]
-  readonly quasis?: readonly { readonly value?: { readonly cooked?: string; readonly raw?: string } }[]
-}
-
-const IMPORTED = 'ImportBinding'
-
-const TYPE_ONLY = 'type'
-
-const QUERIED = 'TSTypeQuery'
-
-let bodies: ReadonlySet<string> | undefined
-
-function operations(): ReadonlySet<string> {
-  if (bodies !== undefined) return bodies
-
-  const prefixed = Object.values(PREFIXES)
-  const found = new Set<string>()
-  for (const [at, threadings] of descend().threaded) {
-    for (const one of threadings) {
-      if (one.list !== 'derives') continue
-      if (one.row.by !== COMPILES) continue
-      if (!prefixed.some((each) => one.by.startsWith(each))) continue
-      found.add(at)
-    }
-  }
-  bodies = found
-  return found
-}
-
-function isBody(path: string): boolean {
-  const known = index().reached
-  if (known.has(path)) return operations().has(path)
-  if (!path.startsWith(UNDER)) return false
-  const file = path.slice(UNDER.length)
-  return !file.includes('/') && Object.values(PREFIXES).some((one) => file.startsWith(one))
-}
-
-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))
-  if (isBody(at)) return true
-  const whole = spellings().get(at)
-  return whole !== undefined && isBody(whole)
-}
-
-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)
-  for (const one of node.quasis ?? []) {
-    const held = one.value?.cooked ?? one.value?.raw
-    if (typeof held === 'string') said.push(held)
-  }
-  for (const value of Object.values(node as Record<string, unknown>)) {
-    if (Array.isArray(value)) for (const one of value) spelled(one as Held, said)
-    else if (value !== null && typeof value === 'object') spelled(value as Held, said)
-  }
-}
-
-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
-}
-
-function walked(
-  node: unknown,
-  up: Held | undefined,
-  seen: (one: Held, parent: Held | undefined) => string | undefined,
-): string | undefined {
-  if (node === null || typeof node !== 'object') return undefined
-  if (Array.isArray(node)) {
-    for (const one of node) {
-      const said = walked(one, up, seen)
-      if (said !== undefined) return said
-    }
-    return undefined
-  }
-  const held = node as Held
-  const real = typeof held.type === 'string'
-  if (real) {
-    const said = seen(held, up)
-    if (said !== undefined) return said
-  }
-  for (const value of Object.values(node as Record<string, unknown>)) {
-    const said = walked(value, real ? held : up, seen)
-    if (said !== undefined) return said
-  }
-  return undefined
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-    if (unreadable(path, at.text) !== undefined) return false
-    if (!parses(path)) return false
-
-    const text = String(at.text)
-    if (!text.includes(UNDER)) return false
-
-    const from = dirname(path)
-
-    let parsed: Parsed
-    try {
-      parsed = (parser.parseForESLint as (t: string, o: unknown) => Parsed)(text, {
-        range: true,
-        ecmaVersion: 'latest',
-        sourceType: 'module',
-        ecmaFeatures: { jsx: true },
-      })
-    } catch {
-      return false
-    }
-
-    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'
-              ? held.arguments?.[0]
-              : undefined
-
-        if (dynamic !== undefined) {
-          const said: string[] = []
-          spelled(dynamic, said)
-          const reaching = said.find((one) => one.includes(UNDER) || reaches(one, from))
-          if (reaching !== undefined) {
-            return (
-              `this reaches \`${reaching}\` at run time, which points at an operation. An operation is handed ` +
-              `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)) return undefined
-        if (parent?.type === QUERIED) return undefined
-        if (
-          parent?.type === 'CallExpression' &&
-          parent.callee?.type === 'Identifier' &&
-          parent.callee.name === INVOKER &&
-          (parent.arguments ?? []).includes(held)
-        ) {
-          return undefined
-        }
-
-        return (
-          `\`${held.name}\` is an operation, and this does something with it other than hand it to ` +
-          `\`${INVOKER}\`. Every gate that decides whether it may run is in \`${INVOKER}\` — naming it, ` +
-          'aliasing it, taking it apart or passing it on all reach past every one of them'
-        )
-      }) ?? false
-    )
-  },
-  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(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)",
-      "import { operation } from './operations/wf_send_invoice.ts'\n\nconst { requires } = operation",
-      "import { operation } from './operations/wf_send_invoice.ts'\n\nlet one\none = operation\nawait one.run(input)",
-      "import { operation } from './operations/wf_send_invoice.ts'\n\nconst [one] = [operation]\n\nawait one.run(input)",
-      "import { operation } from './operations/wf_send_invoice.ts'\n\nawait (0, operation).run(input)",
-      "import { operation } from './operations/wf_send_invoice.ts'\n\nexport { operation }",
-      "const held = await import('./operations/wf_send_invoice.ts')",
-      "const held = require('../operations/wf_send_invoice.ts')",
-      "const held = await import('../operations/' + name + '.ts')",
-      'const held = await import(`../operations/${name}.ts`)',
-    ],
-    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_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",
-      {
-        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.ts

@@ -1,66 +0,0 @@
-import { existsSync, readFileSync } from '../../integrations/disk.ts'
-import { dirname, resolve } from 'node:path'
-
-import type { Slopnator } from '../slopnator.ts'
-import { findTree } from '../../core/tree.ts'
-
-const ROOT = findTree().at
-
-const IMPORTS = /(?:^|\n)\s*import\s+(?!type\s)[^'"]*['"]([^'"]+)['"]/g
-
-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
-
-    const here = resolve(ROOT, at.filename)
-    const there = target(here, spec)
-    if (there === undefined || !existsSync(there)) return false
-
-    for (const found of readFileSync(there, 'utf8').matchAll(IMPORTS)) {
-      const back = found[1] ?? ''
-      if (target(there, back) === here) return `${spec} imports \`${back}\` straight back, so the two initialise each other`
-    }
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'threads/_probe_one.ts', source: "import { two } from './_probe_two.ts'\nexport const one = two\n" },
-          { at: 'threads/_probe_two.ts', source: "import { one } from './_probe_one.ts'\nexport const two = one\n" },
-        ],
-        at: 'threads/_probe_one.ts',
-      },
-    ],
-    right: [
-      "import type { Law } from '../../core/generators/meta.ts'",
-      "import { SLUG, type Shaped } from '../../core/types.ts'",
-      "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',
-      },
-    ],
-  },
-}