@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/slopnators/sl_unthreaded.ts

@@ -1,421 +0,0 @@
-import { parser } from 'typescript-eslint'
-
-import type { Slopnator } from '../slopnator.ts'
-
-import { LISTS as LINEAGE, descend, forget as forgetDescent, read, reached as fromThread, threading } from '../../core/descend.ts'
-import { findTree } from '../../core/tree.ts'
-
-const TREE_AT = findTree()
-const ROOT = `${TREE_AT.at.split('\\').join('/')}/`
-const TREE = TREE_AT.name
-const THREAD_AT = `${TREE_AT.name}/thread.ts`
-const FOLLOWABLE = /\.(ts|tsx|mts|cts|mjs|cjs|js)$/
-const LISTS: ReadonlySet<string> = new Set(LINEAGE)
-
-let tree: Index | undefined
-const parsed = new Map<string, readonly Reach[]>()
-const broke = new Map<string, string>()
-
-export interface Reach {
-  readonly list?: 'declares' | 'derives' | 'seeds'
-  readonly at?: string
-  readonly id?: string
-  readonly describes?: string
-  readonly version?: number
-  readonly governs?: readonly string[]
-  readonly wears?: readonly string[]
-}
-
-export interface Meaning {
-  readonly id: string
-  readonly describes: string
-}
-
-interface Held {
-  readonly type?: string
-  readonly kind?: string
-  readonly name?: string
-  readonly value?: unknown
-  readonly key?: Held
-  readonly computed?: boolean
-  readonly id?: Held
-  readonly typeAnnotation?: Held
-  readonly typeName?: Held
-  readonly elementType?: Held
-  readonly properties?: readonly Held[]
-  readonly elements?: readonly (Held | null)[]
-  readonly declarations?: readonly Held[]
-  readonly body?: readonly Held[]
-  readonly declaration?: Held
-  readonly init?: Held
-}
-
-const keyOf = (property: Held): string | undefined => {
-  if (property.computed === true) return undefined
-  const key = property.key
-  if (key?.type === 'Identifier') return key.name
-  if (key?.type === 'Literal' && typeof key.value === 'string') return key.value
-  return undefined
-}
-
-function annotated(node: Held): string | undefined {
-  let held = node.id?.typeAnnotation?.typeAnnotation
-  while (held !== undefined && (held.type === 'TSArrayType' || held.type === 'TSTypeOperator')) {
-    held = held.elementType ?? held.typeAnnotation
-  }
-  return held?.typeName?.name
-}
-
-export const here = (filename: string): string => {
-  const path = filename.split('\\').join('/')
-  return path.startsWith(ROOT) ? path.slice(ROOT.length) : path
-}
-
-
-
-function rows(node: Held, list: Reach['list'], found: Reach[], hoisted: ReadonlyMap<string, Held>): void {
-  for (const one of node.elements ?? []) {
-    const element = one?.type === 'Identifier' && one.name !== undefined ? hoisted.get(one.name) : one
-    if (element === null || element === undefined || element.type !== 'ObjectExpression') continue
-    const strings: Record<string, string> = {}
-    const said: { at?: string; id?: string; describes?: string; governs?: readonly string[]; wears?: readonly string[] } = {}
-    for (const property of element.properties ?? []) {
-      const key = keyOf(property)
-      const held = property.value as Held | undefined
-      if (key !== undefined && held?.type === 'Literal' && typeof held.value === 'string') strings[key] = held.value
-      if ((key === 'governs' || key === 'wears') && held?.type === 'ArrayExpression') {
-        said[key] = (held.elements ?? [])
-          .map((one) => (one?.type === 'Literal' && typeof one.value === 'string' ? one.value : undefined))
-          .filter((one): one is string => one !== undefined)
-      }
-      if (key !== undefined && LISTS.has(key) && held?.type === 'ArrayExpression') rows(held, key as Reach['list'], found, hoisted)
-    }
-    if (strings['at'] !== undefined) said.at = strings['at']
-    if (strings['id'] !== undefined) said.id = strings['id']
-    if (strings['describes'] !== undefined) said.describes = strings['describes']
-    if (said.at !== undefined || said.id !== undefined) found.push({ list, ...said })
-  }
-}
-
-function reaching(text: string): readonly Reach[] {
-  const already = parsed.get(text)
-  if (already !== undefined) return already
-
-  const types = threading()
-  const found: Reach[] = []
-  const parse = (jsx: boolean): { ast: unknown } =>
-    (parser.parseForESLint as (t: string, o: unknown) => { ast: unknown })(text, {
-      range: true,
-      ecmaVersion: 'latest',
-      sourceType: 'module',
-      ecmaFeatures: { jsx },
-    })
-
-  const read = ((): { ast: unknown } | undefined => {
-    try {
-      return parse(true)
-    } catch {
-      try {
-        return parse(false)
-      } catch (error) {
-        broke.set(text, error instanceof Error ? (error.message.split('\n')[0] ?? error.message) : String(error))
-        return undefined
-      }
-    }
-  })()
-  if (read === undefined) {
-    parsed.set(text, found)
-    return found
-  }
-  const body = (read.ast as unknown as Held).body ?? []
-  const hoisted = new Map<string, Held>()
-  for (const statement of body) {
-    const held = statement.declaration ?? statement
-    if (held.type !== 'VariableDeclaration') continue
-    for (const one of held.declarations ?? []) {
-      const name = one.id?.name
-      if (name !== undefined && one.init?.type === 'ObjectExpression') hoisted.set(name, one.init)
-    }
-  }
-
-  for (const statement of body) {
-    const held = statement.declaration ?? statement
-    if (held.type !== 'VariableDeclaration' || held.kind !== 'const') continue
-    for (const one of held.declarations ?? []) {
-      if (!types.has(annotated(one) ?? '')) continue
-      const init = one.init
-      for (const node of init?.type === 'ArrayExpression' ? (init.elements ?? []) : [init]) {
-        if (node === null || node === undefined || node.type !== 'ObjectExpression') continue
-        const said: { id?: string; describes?: string; version?: number } = {}
-        for (const property of node.properties ?? []) {
-          const key = keyOf(property)
-          const value = property.value as Held | undefined
-          if ((key === 'id' || key === 'describes') && value?.type === 'Literal' && typeof value.value === 'string') said[key] = value.value
-          if (key === 'version' && value?.type === 'Literal' && typeof value.value === 'number') said.version = value.value
-          if (key !== undefined && LISTS.has(key) && value?.type === 'ArrayExpression') rows(value, key as Reach['list'], found, hoisted)
-        }
-        if (said.id !== undefined) found.push({ ...said })
-      }
-    }
-  }
-
-  parsed.set(text, found)
-  return found
-}
-
-export function atsIn(text: string, only?: ReadonlySet<string>): readonly string[] {
-  const found: string[] = []
-  for (const one of reaching(text)) {
-    if (only !== undefined && (one.list === undefined || !only.has(one.list))) continue
-    if (one.at !== undefined) found.push(one.at)
-  }
-  return found
-}
-
-export const rowsIn = (text: string): readonly Reach[] => reaching(text)
-
-const SCHEMA = /^export const ([A-Za-z]+)IslandSchema\b/m
-const DEFINE = /^export function (define[A-Za-z]+)\s*\(/m
-
-export type Governed =
-  | { readonly kind: 'file'; readonly at: string }
-  | { readonly kind: 'folder'; readonly under: string }
-  | { readonly kind: 'pattern'; readonly matching: string; readonly under: string }
-
-export function governedBy(one: string): Governed {
-  if (one.includes('*')) {
-    const cut = one.lastIndexOf('/', one.indexOf('*'))
-    return { kind: 'pattern', matching: one, under: cut === -1 ? '' : one.slice(0, cut + 1) }
-  }
-  if (one.endsWith('/')) return { kind: 'folder', under: one }
-  return { kind: 'file', at: one }
-}
-
-export const filesGoverned = (all: readonly string[]): readonly string[] =>
-  all.map(governedBy).flatMap((one) => (one.kind === 'file' ? [one.at] : []))
-
-export const foldersGoverned = (all: readonly string[]): readonly string[] =>
-  all.map(governedBy).flatMap((one) => (one.kind === 'file' ? [] : [one.under]))
-
-export function governs(all: readonly string[], path: string): boolean {
-  return all.map(governedBy).some((one) => {
-    if (one.kind === 'file') return path === one.at
-    if (one.kind === 'folder') return path.startsWith(one.under)
-    const tail = one.matching.slice(one.under.length).split('*').filter(Boolean)
-    const rest = path.startsWith(one.under) ? path.slice(one.under.length) : undefined
-    return rest !== undefined && tail.every((part) => rest.includes(part))
-  })
-}
-
-export interface Declared {
-  readonly id: string
-  readonly at: string
-  readonly describes: string
-  readonly governs: readonly string[]
-  readonly define?: string
-  readonly tree?: string
-  readonly member?: string
-}
-
-export const canonical = (at: string): string => at.replace(/^threads\//, `${TREE}/`)
-
-export function islandsDeclared(): readonly Declared[] {
-  const found: Declared[] = []
-  const seen = new Set<string>()
-  const all: Reach[] = []
-
-  for (const at of fromThread()) {
-    const held = read(at)
-    if (held === undefined) continue
-    if (unreadable(at, held) !== undefined) continue
-    all.push(...reaching(held))
-  }
-
-  for (const row of all) {
-    if (row.id === undefined || row.at === undefined) continue
-    const at = canonical(row.at)
-    if (seen.has(at)) continue
-    const source = read(at)
-    if (source === undefined || !SCHEMA.test(source)) continue
-    seen.add(at)
-
-    const tree = `${TREE}/${row.id}.ts`
-    const named = all.find((one) => one.at !== undefined && canonical(one.at) === tree)?.id
-
-    found.push({
-      id: row.id,
-      at,
-      describes: row.describes ?? '',
-      governs: row.governs ?? [],
-      define: DEFINE.exec(source)?.[1],
-      ...(named === undefined ? {} : { tree, member: named }),
-    })
-  }
-
-  return found
-}
-
-export const declaresIsland = (text: string): string | undefined => SCHEMA.exec(text)?.[1]
-
-export function meaningsIn(text: string): readonly Meaning[] {
-  const found: Meaning[] = []
-  for (const one of reaching(text)) {
-    if (one.id === undefined) continue
-    found.push({ id: one.id, describes: one.describes ?? '' })
-  }
-  return found
-}
-
-export interface Index {
-  readonly reached: ReadonlySet<string>
-  readonly declared: ReadonlyMap<string, number>
-  readonly meanings: ReadonlyMap<string, ReadonlySet<string>>
-}
-
-
-function descended(): Index {
-  const pass = descend()
-  const reached = new Set<string>([THREAD_AT, ...pass.threaded.keys()])
-  const declared = new Map<string, number>()
-  for (const [at, held] of pass.threaded) declared.set(at, held.filter((one) => one.list === 'declares').length)
-  const meanings = new Map<string, ReadonlySet<string>>()
-  for (const [word, held] of pass.coined) meanings.set(word, new Set(held.said))
-  return { reached, declared, meanings }
-}
-
-export function index(): Index {
-  tree ??= descended()
-  return tree
-}
-
-export function forget(): void {
-  parsed.clear()
-  broke.clear()
-  tree = undefined
-  forgetDescent()
-}
-
-export const threaded = (): ReadonlySet<string> => index().reached
-
-export const parses = (path: string): boolean => FOLLOWABLE.test(path)
-
-export function unreadable(path: string, text: string): string | undefined {
-  if (!parses(path)) return undefined
-  atsIn(text)
-  const said = broke.get(text)
-  if (said === undefined) return undefined
-  return `this file cannot be parsed, so no law that reads its structure measured anything on it — ${said}`
-}
-
-export const names = (path: string, text: string): readonly string[] => (parses(path) ? atsIn(text) : [])
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-    if (path === THREAD_AT) return false
-    const why = unreadable(path, at.text)
-    if (why !== undefined) return why
-    const pass = descend()
-    if (pass.threaded.has(path)) return false
-    if (names(path, at.text).length > 0) return false
-    const by = pass.mentioned.get(path) ?? []
-    const cut = by.filter((one) => one !== THREAD_AT && !pass.threaded.has(one))
-    if (cut.length > 0) {
-      return `broken thread — ${cut.join(' and ')} names ${path}, and nothing declares ${cut.length === 1 ? 'it' : 'them'}, so the descent from ${THREAD_AT} never arrives`
-    }
-    if (by.length > 0) {
-      return `broken thread — ${by.join(' and ')} names ${path} and is itself declared, and the descent still never arrived, so the row was read and never walked`
-    }
-    return `nothing that traces back to ${TREE}/ names ${path}, so the descent from ${THREAD_AT} never reaches it`
-  },
-  proves: {
-    wrong: [
-      'export const ORPHAN = 2',
-      'export const LOOSE = { id: 2 }',
-      {
-        files: [
-          { at: 'threads/_names_it.ts', source: "export const OWNER = {\n  declares: [\n    {\n      at: 'scripts/_probe_bare.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_bare.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_bare.ts',
-      },
-      {
-        files: [
-          {
-            at: 'threads/_names_it.ts',
-            source:
-              "export const REAL: Threaded = {\n  declares: [\n    {\n      at: 'threads/_names_it.ts',\n    },\n  ],\n}\n\nexport const BARE = {\n  declares: [\n    {\n      at: 'scripts/_probe_after.ts',\n    },\n  ],\n}\n",
-          },
-          { at: 'scripts/_probe_after.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_after.ts',
-      },
-      {
-        files: [
-          { at: 'threads/_names_it.ts', source: "export let LOOSE = {\n  declares: [\n    {\n      at: 'scripts/_probe_let.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_let.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_let.ts',
-      },
-      {
-        files: [
-          { at: 'threads/_names_it.ts', source: "export var LOOSE = {\n  declares: [\n    {\n      at: 'scripts/_probe_var.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_var.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_var.ts',
-      },
-      {
-        files: [
-          { at: 'threads/_names_it.ts', source: "export default {\n  declares: [\n    {\n      at: 'scripts/_probe_default.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_default.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_default.ts',
-      },
-      {
-        files: [
-          { at: 'threads/_names_it.ts', source: "export function held() {\n  return {\n    declares: [\n      {\n        at: 'scripts/_probe_fn.ts',\n      },\n    ],\n  }\n}\n" },
-          { at: 'scripts/_probe_fn.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_fn.ts',
-      },
-      {
-        files: [
-          { at: 'threads/_names_it.ts', source: "export class Held {\n  held = {\n    declares: [\n      {\n        at: 'scripts/_probe_class.ts',\n      },\n    ],\n  }\n}\n" },
-          { at: 'scripts/_probe_class.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_class.ts',
-      },
-      {
-        files: [
-          {
-            at: 'threads/_names_it.ts',
-            source: "interface Held { declares: unknown[] }\nexport const FAKE: Held = {\n  declares: [\n    {\n      at: 'scripts/_probe_fake.ts',\n    },\n  ],\n}\n",
-          },
-          { at: 'scripts/_probe_fake.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_fake.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/_names_it.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_names_it.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const OWNER: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_child.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_child.ts', source: 'export const CHILD = 1\n' },
-        ],
-        at: 'scripts/_probe_child.ts',
-      },
-      {
-        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/_names_it.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_names_it.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const OWNER: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_parent.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_parent.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const MID: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_leaf.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_leaf.ts', source: 'export const LEAF = 1\n' },
-        ],
-        at: 'scripts/_probe_leaf.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_untranslated_key.ts

@@ -1,140 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from '../../integrations/disk.ts'
-import { join } from 'node:path'
-
-import type { Slopnator } from '../slopnator.ts'
-import { named as packageOf } from '../../core/scope.ts'
-
-const SKIP = new Set(['node_modules', '.next', '.git', 'dist', '_generated'])
-
-const CODE = /\.(tsx?|jsx?)$/
-
-const TYPED = /readonly\s+([A-Za-z][A-Za-z0-9]*)\??\s*:\s*MessageKey\b/g
-
-function walk(at: string, found: string[] = []): readonly string[] {
-  let entries: readonly { name: string; isDirectory: () => boolean }[]
-  try {
-    entries = readdirSync(at, { withFileTypes: true })
-  } catch {
-    return found
-  }
-  for (const entry of entries) {
-    if (SKIP.has(entry.name)) continue
-    const path = join(at, entry.name)
-    if (entry.isDirectory()) walk(path, found)
-    else if (CODE.test(entry.name)) found.push(path)
-  }
-  return found
-}
-
-function keyProps(root: string): readonly string[] {
-  const found = new Set<string>()
-  const home = join(root, 'node_modules', packageOf('ui'))
-  if (!existsSync(home)) return []
-  for (const file of walk(home)) {
-    for (const one of readFileSync(file, 'utf8').matchAll(TYPED)) found.add(one[1] ?? '')
-  }
-  return [...found].sort()
-}
-
-function languagesIn(root: string): { readonly held: readonly string[]; readonly source: string | undefined } {
-  const at = join(root, '_threads', 'localizations.ts')
-  if (!existsSync(at)) return { held: [], source: undefined }
-  const text = readFileSync(at, 'utf8')
-  const held: string[] = []
-  let source: string | undefined
-  for (const one of text.matchAll(/id:\s*(?:SOURCE_ROW|'([^']+)')\s*,[\s\S]{0,200}?is:\s*'([^']*)'/g)) {
-    const id = one[1]
-    if (id === undefined || id === 'source') {
-      source = one[2]
-      continue
-    }
-    held.push(id)
-  }
-  return { held, source }
-}
-
-export const slopnator: Slopnator = {
-  checks: (root) => {
-    const { held } = languagesIn(root)
-    if (held.length === 0) return []
-
-    const props = keyProps(root)
-    if (props.length === 0) return []
-
-    const named = new RegExp(`\\b(?:${props.join('|')})\\s*=\\s*"([^"]+)"`, 'g')
-
-    const used = new Map<string, string>()
-    for (const file of walk(root)) {
-      const text = readFileSync(file, 'utf8')
-      for (const one of text.matchAll(named)) {
-        const key = one[1] ?? ''
-        if (!used.has(key)) used.set(key, file.slice(root.length).replace(/^\/+/, ''))
-      }
-    }
-    if (used.size === 0) return []
-
-    const findings: string[] = []
-    for (const language of held) {
-      const at = join(root, 'i18n', `${language}.json`)
-      if (!existsSync(at)) {
-        findings.push(
-          `i18n/${language}.json is not there and \`${language}\` is a declared language, so every key this ` +
-            'interface names goes unanswered in it — run `thread i18n`',
-        )
-        continue
-      }
-      let wording: Readonly<Record<string, unknown>>
-      try {
-        wording = JSON.parse(readFileSync(at, 'utf8')) as Readonly<Record<string, unknown>>
-      } catch {
-        findings.push(
-          `i18n/${language}.json will not parse, so what this app says in \`${language}\` cannot be known — ` +
-            'a reader that cannot read is not a reader that found nothing',
-        )
-        continue
-      }
-      for (const [key, where] of [...used].sort()) {
-        const said = wording[key]
-        if (typeof said === 'string' && said !== '') continue
-        findings.push(
-          `\`${key}\` is named by ${where} and says nothing in \`${language}\` — an untranslated key is a ` +
-            'blank on the screen, and it is an error rather than a word that comes out in the wrong language',
-        )
-      }
-    }
-    return findings
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: '_threads/localizations.ts', source: "export const LOCALIZATION = {\n  holds: [\n    { id: 'source', is: 'en' },\n    { id: 'en', is: 'English' },\n  ],\n}\n" },
-          { at: `node_modules/${packageOf('ui')}/probe.ts`, source: 'export interface P {\n  readonly label: MessageKey\n}\n' },
-          { at: 'compositions/cmp_probe.tsx', source: 'export const P = () => <Button label="probe.blank" />\n' },
-          { at: 'i18n/en.json', source: '{\n  "probe.blank": ""\n}\n' },
-        ],
-        at: 'compositions/cmp_probe.tsx',
-      },
-      {
-        files: [
-          { at: '_threads/localizations.ts', source: "export const LOCALIZATION = {\n  holds: [\n    { id: 'source', is: 'en' },\n    { id: 'en', is: 'English' },\n  ],\n}\n" },
-          { at: `node_modules/${packageOf('ui')}/probe.ts`, source: 'export interface P {\n  readonly label: MessageKey\n}\n' },
-          { at: 'compositions/cmp_probe.tsx', source: 'export const P = () => <Button label="probe.missing" />\n' },
-          { at: 'i18n/en.json', source: '{\n  "probe.other": "Something"\n}\n' },
-        ],
-        at: 'compositions/cmp_probe.tsx',
-      },
-    ],
-    right: [
-      {
-        files: [
-          { at: '_threads/localizations.ts', source: "export const LOCALIZATION = {\n  holds: [\n    { id: 'source', is: 'en' },\n    { id: 'en', is: 'English' },\n  ],\n}\n" },
-          { at: `node_modules/${packageOf('ui')}/probe.ts`, source: 'export interface P {\n  readonly label: MessageKey\n}\n' },
-          { at: 'compositions/cmp_probe.tsx', source: 'export const P = () => <Button label="probe.answered" />\n' },
-          { at: 'i18n/en.json', source: '{\n  "probe.answered": "Answered"\n}\n' },
-        ],
-        at: 'compositions/cmp_probe.tsx',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_unvaulted_secret.ts

@@ -1,132 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-
-import { descend, read, reached } from '../../core/descend.ts'
-import { rowsIn } from './sl_unthreaded.ts'
-
-interface Held {
-  readonly type?: string
-  readonly name?: string
-  readonly value?: unknown
-  readonly computed?: boolean
-  readonly object?: Held
-  readonly property?: Held
-  readonly init?: Held
-  readonly id?: Held
-  readonly declaration?: Held
-  readonly declarations?: readonly Held[]
-  readonly left?: Held
-}
-
-const SECRETS = 'secrets'
-
-function wears(): readonly 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 === SECRETS) {
-        for (const id of waiting) {
-          const cut = id.indexOf('_')
-          if (cut > 0) found.add(id.slice(0, cut + 1))
-        }
-      }
-      waiting = []
-    }
-  }
-
-  return [...found]
-}
-
-const HOLDS = 'process'
-
-const ENV = 'env'
-
-const isEnv = (one: Held | undefined): boolean =>
-  one?.type === 'MemberExpression' &&
-  one.object?.type === 'Identifier' &&
-  one.object.name === HOLDS &&
-  one.property?.type === 'Identifier' &&
-  one.property.name === ENV
-
-function stated(node: Held | undefined, ancestors: readonly unknown[]): string | undefined {
-  if (node === undefined) return undefined
-  if (node.type === 'Literal' && typeof node.value === 'string') return node.value
-  if (node.type !== 'Identifier' || node.name === undefined) return undefined
-  for (const one of ancestors) {
-    const body = (one as { readonly body?: unknown }).body
-    for (const each of Array.isArray(body) ? (body as readonly unknown[]) : []) {
-      const line = each as Held
-      const held = line.type === 'ExportNamedDeclaration' ? line.declaration : line
-      if (held?.type !== 'VariableDeclaration') continue
-      for (const said of held.declarations ?? []) {
-        if (said.id?.type !== 'Identifier' || said.id.name !== node.name) continue
-        return said.init?.type === 'Literal' && typeof said.init.value === 'string' ? said.init.value : undefined
-      }
-    }
-  }
-  return undefined
-}
-
-export const slopnator: Slopnator = {
-  on: ['MemberExpression'],
-  holds: (node, at) => {
-    const held = node as Held
-    if (!isEnv(held.object)) return false
-
-    const up = at.ancestors()
-    const parent = up[up.length - 1] as Held | undefined
-    if (parent?.type === 'AssignmentExpression' && parent.left === held) return false
-
-    const name = held.computed === true ? stated(held.property, up) : held.property?.name
-
-    if (name === undefined) {
-      return (
-        'this takes a value out of the environment under a name nobody reading the file can see, so it can name ' +
-        'any secret this app declares. A declared value is opened by the vault, which refuses a name no row states ' +
-        'and a value nothing sealed, and neither of those refusals can happen here'
-      )
-    }
-
-    const wearing = wears().find((one) => name.toLowerCase().startsWith(one))
-    if (wearing === undefined) return false
-
-    return (
-      name +
-      ' wears the prefix ' +
-      wearing +
-      ', so it names a secret, and this takes it from the environment instead of the vault — past the check that a ' +
-      'row declares it, and past the sealed store the value was written to'
-    )
-  },
-  proves: {
-    wrong: [
-      'const key = process.env[named.toUpperCase()]',
-      {
-        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_secrets.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_probe_secrets.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const SECRETS: Threaded = {\n  id: 'secrets',\n  declares: [\n    {\n      id: 'sec_model',\n      at: 'threads/_probe_secrets.ts',\n    },\n  ],\n}\n" },
-          { at: 'probe.tsx', source: "const key = process.env['SEC_MODEL']\n" },
-        ],
-        at: 'probe.tsx',
-      },
-    ],
-    right: [
-      "const mode = process.env['NODE_ENV']",
-      "const DEPTH = 'THREAD_DEPTH'\n\nconst depth = Number(process.env[DEPTH] ?? '0')",
-      "const held = opened(['sec_model'])",
-    ],
-  },
-}