@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/lsp/server.ts

@@ -1,224 +0,0 @@
-import { relative as relativeTo, resolve } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-
-import { named } from '../../core/scope.ts'
-import { report, SOURCE_NAME, type Diagnostic, type DiagnosticSource } from './diagnostics.ts'
-import { METHOD_NOT_FOUND, type RpcMessage } from './protocol.ts'
-
-const SYNC_FULL = 1
-
-export interface ServerOptions {
-
-  readonly root: string
-
-  readonly sourceFor: (root: string) => DiagnosticSource
-  send(message: RpcMessage): void
-
-  settle?(): Promise<void>
-}
-
-interface TextDocumentIdentifier {
-  readonly uri?: unknown
-}
-
-interface DidOpenParams {
-  readonly textDocument?: { readonly uri?: unknown; readonly text?: unknown }
-}
-
-interface DidChangeParams {
-  readonly textDocument?: TextDocumentIdentifier
-  readonly contentChanges?: readonly { readonly text?: unknown }[]
-}
-
-interface InitializeParams {
-  readonly rootUri?: unknown
-  readonly rootPath?: unknown
-  readonly workspaceFolders?: readonly { readonly uri?: unknown }[] | null
-}
-
-export class LspServer {
-  #root: string
-  readonly #options: ServerOptions
-
-  readonly #open = new Map<string, string>()
-
-  #published = new Set<string>()
-
-  #running = false
-  #again = false
-  #shutdownRequested = false
-  #exited = false
-
-  constructor(options: ServerOptions) {
-    this.#options = options
-    this.#root = options.root
-  }
-
-  get exited(): boolean {
-    return this.#exited
-  }
-
-  get exitCode(): number {
-    return this.#shutdownRequested ? 0 : 1
-  }
-
-  async handle(message: RpcMessage): Promise<void> {
-
-    if (message.method === undefined) return
-
-    switch (message.method) {
-      case 'initialize':
-        this.#root = rootIn(message.params as InitializeParams | undefined) ?? this.#root
-        this.#reply(message.id, {
-          capabilities: {
-            textDocumentSync: { openClose: true, change: SYNC_FULL, save: true },
-
-            diagnosticProvider: {
-              identifier: SOURCE_NAME,
-
-              interFileDependencies: true,
-              workspaceDiagnostics: false,
-            },
-          },
-          serverInfo: { name: named('integrity') },
-        })
-        return
-
-      case 'initialized':
-
-        return
-
-      case 'shutdown':
-        this.#shutdownRequested = true
-        this.#reply(message.id, null)
-        return
-
-      case 'exit':
-        this.#exited = true
-        return
-
-      case 'textDocument/didOpen': {
-        const params = message.params as DidOpenParams | undefined
-        const path = this.#pathOf(params?.textDocument?.uri)
-        if (path === undefined) return
-        this.#open.set(path, typeof params?.textDocument?.text === 'string' ? params.textDocument.text : '')
-        await this.#recompute()
-        return
-      }
-
-      case 'textDocument/didChange': {
-        const params = message.params as DidChangeParams | undefined
-        const path = this.#pathOf(params?.textDocument?.uri)
-        if (path === undefined) return
-
-        const latest = params?.contentChanges?.at(-1)?.text
-        if (typeof latest === 'string') this.#open.set(path, latest)
-        await this.#recompute()
-        return
-      }
-
-      case 'textDocument/didSave':
-        await this.#recompute()
-        return
-
-      case 'textDocument/didClose': {
-        const path = this.#pathOf((message.params as DidOpenParams | undefined)?.textDocument?.uri)
-        if (path === undefined) return
-        this.#open.delete(path)
-        await this.#recompute()
-        return
-      }
-
-      case 'textDocument/diagnostic': {
-        const path = this.#pathOf((message.params as DidOpenParams | undefined)?.textDocument?.uri)
-        const computed = await report(this.#sourceForRoot(), this.#open, this.#published)
-        this.#published = new Set([...computed].filter(([, list]) => list.length > 0).map(([file]) => file))
-        this.#reply(message.id, {
-          kind: 'full',
-          items: path === undefined ? [] : (computed.get(path) ?? []),
-        })
-        return
-      }
-
-      default:
-
-        if (message.id !== undefined && message.id !== null) {
-          this.#options.send({
-            jsonrpc: '2.0',
-            id: message.id,
-            error: { code: METHOD_NOT_FOUND, message: `${message.method} is not implemented by ${SOURCE_NAME}` },
-          })
-        }
-    }
-  }
-
-  #sourceForRoot(): DiagnosticSource {
-    return this.#options.sourceFor(this.#root)
-  }
-
-  #reply(id: RpcMessage['id'], result: unknown): void {
-    if (id === undefined || id === null) return
-    this.#options.send({ jsonrpc: '2.0', id, result })
-  }
-
-  async #recompute(): Promise<void> {
-    if (this.#running) {
-      this.#again = true
-      return
-    }
-
-    this.#running = true
-    try {
-      do {
-        this.#again = false
-        await (this.#options.settle?.() ?? sleep(200))
-        const computed = await report(this.#sourceForRoot(), this.#open, this.#published)
-
-        const nonEmpty = new Set<string>()
-        for (const [path, diagnostics] of computed) {
-          this.#publish(path, diagnostics)
-          if (diagnostics.length > 0) nonEmpty.add(path)
-        }
-        this.#published = nonEmpty
-      } while (this.#again)
-    } finally {
-      this.#running = false
-    }
-  }
-
-  #publish(path: string, diagnostics: readonly Diagnostic[]): void {
-    this.#options.send({
-      jsonrpc: '2.0',
-      method: 'textDocument/publishDiagnostics',
-      params: { uri: pathToFileURL(resolve(this.#root, path)).href, diagnostics },
-    })
-  }
-
-  #pathOf(uri: unknown): string | undefined {
-    if (typeof uri !== 'string' || !uri.startsWith('file://')) return undefined
-    let absolute: string
-    try {
-      absolute = fileURLToPath(uri)
-    } catch {
-      return undefined
-    }
-    const path = relativeTo(this.#root, absolute).split('\\').join('/')
-
-    return path.startsWith('..') || path.startsWith('/') ? undefined : path
-  }
-}
-
-const sleep = (ms: number): Promise<void> => new Promise((done) => setTimeout(done, ms))
-
-function rootIn(params: InitializeParams | undefined): string | undefined {
-  const folder = params?.workspaceFolders?.[0]?.uri
-  for (const uri of [folder, params?.rootUri]) {
-    if (typeof uri !== 'string' || !uri.startsWith('file://')) continue
-    try {
-      return fileURLToPath(uri)
-    } catch {
-      continue
-    }
-  }
-  return typeof params?.rootPath === 'string' ? params.rootPath : undefined
-}

package/dist/integrity/slopnator.ts

@@ -1,324 +0,0 @@
-import { existsSync, readFileSync, readdirSync, writeFileSync } from '../integrations/disk.ts'
-import { dirname, join } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-
-import { descend } from '../core/descend.ts'
-import { governs as reaches, islandsDeclared } from './slopnators/sl_unthreaded.ts'
-import { invoked } from '../core/invoked.ts'
-
-import { listBounds, quoted, withSeed } from '../core/rows.ts'
-
-import { CONSTRAINTS, type Constraint, type Proof } from './constraint.ts'
-import { findTree, inTree } from '../core/tree.ts'
-
-export const NOT_WRITTEN = Symbol.for('thread.slopnator.not_written')
-
-const HOME = dirname(fileURLToPath(import.meta.url))
-
-export const SHIPPED = `${HOME}/slopnators`
-
-export const SEEDED = `${findTree().name}/slopnators`
-
-function homes(root: string): readonly string[] {
-  return [SHIPPED, join(root, SEEDED)]
-}
-
-export const ROOT = `${findTree().at}/`
-
-export interface SlopnatorContext {
-  readonly filename: string
-  readonly text: string
-  readonly ancestors: () => readonly unknown[]
-  readonly comments: () => readonly Spoken[]
-}
-
-export interface Spoken {
-  readonly value: string
-  readonly range: readonly [number, number]
-}
-
-export interface Proves {
-  readonly wrong: readonly Proof[]
-  readonly right: readonly Proof[]
-}
-
-export interface Reads {
-  readonly holds: (node: unknown, at: SlopnatorContext) => boolean | string | typeof NOT_WRITTEN
-  readonly fixes?: (node: unknown, at: SlopnatorContext) => string | undefined
-  readonly proves: Proves
-}
-
-export interface Reading extends Reads {
-  readonly on?: readonly string[]
-}
-
-export interface Running {
-  readonly checks: (root: string) => readonly string[]
-  readonly proves: Proves
-}
-
-export type Slopnator = Reading | Running
-
-export type Visiting = Reading & { readonly on: readonly string[] }
-
-export const reads = (one: Slopnator): one is Reading => 'holds' in one
-
-export const visits = (one: Slopnator): one is Visiting => 'holds' in one && one.on !== undefined
-
-export const sweeps = (one: Slopnator): one is Reading => 'holds' in one && one.on === undefined
-
-export interface Byproduct {
-  readonly path: string
-  readonly content: string
-}
-
-export function slopnatorName(rule: string): string {
-  return `sl_${rule
-    .replace(/[^a-zA-Z0-9]+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    .toLowerCase()}`
-}
-
-const CANONICAL_TREE = 'threads'
-
-const TREE = findTree().name
-
-function parts(one: string): readonly string[] {
-  return one.split('\\').join('/').split('/').filter((part) => part !== '')
-}
-
-function wanted(fragment: string): readonly string[] {
-  const all = parts(fragment)
-  return all[0] === CANONICAL_TREE ? [TREE, ...all.slice(1)] : all
-}
-
-function holding(want: readonly string[], path: readonly string[], from: number): boolean {
-  return want.every((part, step) => part === path[from + step])
-}
-
-export function region(fragment: string, path: readonly string[]): boolean {
-  if (fragment === '.') return true
-  const want = wanted(fragment)
-  if (want.length === 0) return false
-  if (!fragment.endsWith('/')) return want.join('/') === path.join('/')
-  return want.length < path.length && holding(want, path, 0)
-}
-
-let written: ReadonlySet<string> | undefined
-
-export function derivedHere(): ReadonlySet<string> | undefined {
-  if (written !== undefined) return written
-  try {
-    const found = new Set<string>()
-    for (const [at, threadings] of descend().threaded) {
-      if (threadings.some((one) => one.list === 'derives' && (one.row.by ?? one.row.runs) !== undefined)) found.add(at)
-    }
-    written = found
-    return written
-  } catch {
-    return undefined
-  }
-}
-
-const islands = new WeakMap<object, ReadonlyMap<string, readonly string[]>>()
-
-function islandsHere(): ReadonlyMap<string, readonly string[]> | undefined {
-  try {
-    const pass = descend()
-    const known = islands.get(pass)
-    if (known !== undefined) return known
-    const named = new Map(islandsDeclared().map((one) => [one.id, one.governs]))
-    islands.set(pass, named)
-    return named
-  } catch {
-    return undefined
-  }
-}
-
-export function subject(rule: Constraint): boolean {
-  if (rule.governs === undefined) return true
-  const named = islandsHere()
-  return named === undefined || named.has(rule.governs)
-}
-
-export function governs(rule: Constraint, filename: string): boolean {
-  const under = filename.startsWith(ROOT) ? filename.slice(ROOT.length) : filename
-  const path = parts(under)
-  if (rule.governs !== undefined) {
-    const body = islandsHere()?.get(rule.governs)
-    if (body !== undefined && reaches(body, under)) return false
-  }
-  if (!rule.where.paths.some((fragment) => region(fragment, path))) return false
-  return derivedHere()?.has(under) !== true
-}
-
-export class UnloadableSlopnatorError extends Error {
-  constructor(rule: string, at: string, because: string) {
-    super(
-      `rule "${rule}" names a slopnator at ${at}, the file is on disk, and loading it threw: ${because}. ` +
-        'A slopnated that cannot be imported reads from every caller exactly like a slopnator that found nothing — ' +
-        'the sweep skips it, the trial falls through, and the rule reports green while enforcing nothing. ' +
-        'Fix the import, or delete the rule.',
-    )
-    this.name = 'UnloadableSlopnatorError'
-  }
-}
-
-export class UnreadableRulesError extends Error {
-  constructor(at: string, because: string) {
-    super(
-      `${at} is where this tree states the rules it authors, and reading it threw: ${because}. ` +
-        'A tree whose rules cannot be read reports exactly like a tree that declared none — every surface runs, finds nothing of its own, and exits 0. ' +
-        'Fix the file, or delete it if this tree authors no rules of its own.',
-    )
-    this.name = 'UnreadableRulesError'
-  }
-}
-
-export async function load(root: string, all: readonly Constraint[]): Promise<ReadonlyMap<string, Slopnator>> {
-  const found = new Map<string, Slopnator>()
-  for (const rule of all) {
-    const name = slopnatorName(rule.id)
-    const at = homes(root)
-      .flatMap((dir) => [join(dir, `${name}.js`), join(dir, `${name}.ts`)])
-      .find((one) => existsSync(one))
-    if (at === undefined) continue
-
-    let module: unknown
-    try {
-      module = await import(pathToFileURL(at).href)
-    } catch (thrown) {
-      throw new UnloadableSlopnatorError(rule.id, at, thrown instanceof Error ? thrown.message : String(thrown))
-    }
-
-    const one = (module as { slopnator?: Slopnator }).slopnator
-    if (one === undefined) {
-      throw new UnloadableSlopnatorError(rule.id, at, 'it exports no `slopnator`')
-    }
-    found.set(name, one)
-  }
-  return found
-}
-
-export function proofsOf(
-  rule: Constraint,
-  slopnators: ReadonlyMap<string, Slopnator>,
-): { readonly wrong: readonly Proof[]; readonly right: readonly Proof[] } {
-  const slopnator = slopnators.get(slopnatorName(rule.id))
-  const slopnated = slopnator?.proves
-  const own = (slopnated?.wrong.length ?? 0) + (slopnated?.right.length ?? 0)
-  if (slopnator !== undefined && !reads(slopnator) && own > 0) {
-    return { wrong: slopnated?.wrong ?? [], right: slopnated?.right ?? [] }
-  }
-  return { wrong: [rule.wrong, ...(slopnated?.wrong ?? [])], right: [rule.right, ...(slopnated?.right ?? [])] }
-}
-
-export function scaffold(): string {
-  return `import { NOT_WRITTEN, type Slopnator } from './slopnator.ts'
-
-export const slopnator: Slopnator = {
-  on: [],
-  holds: () => NOT_WRITTEN,
-  proves: { wrong: [], right: [] },
-}
-`
-}
-
-export function write(root: string, byproduct: Byproduct): void {
-  const path = join(root, byproduct.path)
-  writeFileSync(path, byproduct.content, 'utf8')
-}
-
-export function onDisk(root: string): readonly string[] {
-  const found = new Set<string>()
-  for (const dir of homes(root)) {
-    if (!existsSync(dir)) continue
-    for (const file of readdirSync(dir)) {
-      if (file.startsWith('sl_') && file.endsWith('.ts')) found.add(file.replace(/\.ts$/, ''))
-    }
-  }
-  return [...found].sort()
-}
-
-export function named(all: readonly Constraint[]): readonly string[] {
-  return all.map((rule) => slopnatorName(rule.id)).sort()
-}
-
-export async function rules(): Promise<readonly Constraint[] | undefined> {
-  const at = inTree(findTree(), 'rules.ts')
-  if (!existsSync(at)) return undefined
-  let module: { RULES?: readonly Constraint[] }
-  try {
-    module = (await import(pathToFileURL(at).href)) as { RULES?: readonly Constraint[] }
-  } catch (thrown) {
-    throw new UnreadableRulesError(at, thrown instanceof Error ? thrown.message : String(thrown))
-  }
-  if (module.RULES === undefined) throw new UnreadableRulesError(at, 'it exports no `RULES`')
-  return module.RULES
-}
-
-export function seeds(root: string, all: readonly Constraint[]): readonly Byproduct[] {
-  const found = onDisk(root)
-  return named(all)
-    .filter((wanted) => !found.includes(wanted))
-    .map((wanted) => ({ path: `${SEEDED}/${wanted}.ts`, content: scaffold() }))
-}
-
-export const GENERALLY =
-  'The check the rule beside it refuses with. The rule says what is banned and this finds it, reading every file that rule governs and answering whether each one breaks it.'
-
-export function declaring(at: string, says: string): string {
-  return [
-    '      {',
-    "        id: 'slopnator',",
-    `        at: '${at}',`,
-    `        describes: ${quoted(says)},`,
-    '      },',
-  ].join('\n')
-}
-
-export async function declareSeeded(root: string, ids: readonly string[], says?: string): Promise<readonly string[]> {
-  if (ids.length === 0) return []
-  const at = inTree(findTree(), 'rules.ts')
-  let text: string
-  try {
-    text = readFileSync(at, 'utf8')
-  } catch {
-    return []
-  }
-  const where = listBounds(text, 'RULES')
-  if (where === undefined) return []
-
-  const done: string[] = []
-  for (const id of ids) {
-    const next = withSeed(
-      text,
-      listBounds(text, 'RULES') ?? where,
-      id,
-      declaring(`${SEEDED}/${slopnatorName(id)}.ts`, says ?? GENERALLY),
-    )
-    if (next === text) continue
-    text = next
-    done.push(id)
-  }
-  if (done.length > 0) writeFileSync(at, text, 'utf8')
-  return done
-}
-
-if (invoked(import.meta.url)) {
-  const own = (await rules()) ?? []
-  const seeded = seeds(ROOT, own)
-  for (const byproduct of seeded) {
-    write(ROOT, byproduct)
-    console.log(`slopnator: seeded ${byproduct.path}`)
-  }
-
-  const held = new Set(onDisk(ROOT))
-  const declared = await declareSeeded(ROOT, own.filter((rule) => held.has(slopnatorName(rule.id))).map((rule) => rule.id))
-  for (const id of declared) console.log(`slopnator: declared the slopnator for "${id}" in its own row`)
-
-  console.log(
-    `slopnator: ${String(own.length)} rule(s), ${String(seeded.length)} seeded, ${String(declared.length)} declared. ` +
-      `${String(CONSTRAINTS.length)} shipped constraint(s) are authored, not seeded — unpaired-slopnator refuses one whose slopnated is missing.`,
-  )
-}

package/dist/integrity/slopnators/sl_broken_lineage.ts

@@ -1,38 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-import { here, names, threaded, unreadable } from './sl_unthreaded.ts'
-import { findTree } from '../../core/tree.ts'
-
-const THREAD_AT = `${findTree().name}/thread.ts`
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-    if (path === THREAD_AT) return false
-
-    if (unreadable(path, at.text) !== undefined) return false
-    const children = names(path, at.text)
-    if (children.length === 0) return false
-    if (threaded().has(path)) return false
-
-    return `this file names ${String(children.length)} child(ren) — ${children.slice(0, 3).join(', ')} — and its own origin does not trace back to threads/, so everything it parents is stranded with it`
-  },
-  proves: {
-    wrong: [
-      "export const M: Threaded = {\n  declares: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}",
-      "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}",
-    ],
-    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_mid.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_mid.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const MID: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_end.ts',\n    },\n  ],\n}\n" },
-          { at: 'scripts/_probe_end.ts', source: 'export const END = 1\n' },
-        ],
-        at: 'scripts/_probe_mid.ts',
-      },
-      'export const PLAIN = 1',
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_declared_elsewhere.ts

@@ -1,60 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-import { filesGoverned, here, islandsDeclared } from './sl_unthreaded.ts'
-
-const sentence = (describes: string): string => `${describes.split(/ — |\. /)[0] ?? describes}.`
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-
-    for (const island of islandsDeclared()) {
-      if (island.define === undefined) continue
-      const call = new RegExp(`(?<!function\\s)\\b${island.define}\\s*\\(`)
-      if (!call.test(at.text)) continue
-
-      const places = filesGoverned(island.governs)
-      if (places.includes(path)) continue
-
-      const where = places.length === 0 ? 'nowhere — its kind is derived, never authored' : places.join(' or ')
-      return (
-        `\`${island.define}\` is called here and the "${island.id}" island governs ${where}, so the loader never opens this ` +
-        `file for it and the declaration produces nothing. ${sentence(island.describes)}`
-      )
-    }
-
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'threads/thread.ts', source: "export const THREAD: Threaded = {\n  declares: [\n    { id: 'events', at: 'src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n" },
-          { at: 'src/islands/events.ts', source: 'export const EventsIslandSchema = {}\nexport function defineEvents() {}\n' },
-          { at: 'probe.tsx', source: 'export default defineEvents({ specVersion: 1, events: [] })\n' },
-        ],
-        at: 'probe.tsx',
-      },
-      {
-        files: [
-          { at: 'threads/thread.ts', source: "export const THREAD: Threaded = {\n  declares: [\n    { id: 'permissions', at: 'src/islands/permissions.ts', governs: ['app/_declare/permissions.ts'] },\n  ],\n}\n" },
-          { at: 'src/islands/permissions.ts', source: 'export const PermissionsIslandSchema = {}\nexport function definePermissions() {}\n' },
-          { at: 'probe.tsx', source: 'export default definePermissions({ specVersion: 1, entities: [] })\n' },
-        ],
-        at: 'probe.tsx',
-      },
-      {
-        files: [
-          { at: 'threads/thread.ts', source: "export const THREAD: Threaded = {\n  declares: [\n    { id: 'navigation', at: 'src/islands/navigation.ts', governs: ['app/_declare/map.ts'] },\n  ],\n}\n" },
-          { at: 'src/islands/navigation.ts', source: 'export const NavigationIslandSchema = {}\nexport function defineMap() {}\n' },
-          { at: 'probe.tsx', source: 'export default defineMap({ specVersion: 1, screens: [] })\n' },
-        ],
-        at: 'probe.tsx',
-      },
-    ],
-    right: [
-      "import events from 'app/_declare/events'",
-      "import permissions from 'app/_declare/permissions'",
-      'const screens = useRead(recentScreens)',
-    ],
-  },
-}