@prestack/thread 0.1.21 → 0.1.23

package/dist/integrations/disk.ts

@@ -1,466 +0,0 @@
-import * as disk from 'node:fs'
-import { basename, dirname, isAbsolute, relative, resolve } from 'node:path'
-import { env, pid } from 'node:process'
-
-import { ORDERS, type Answer, type Attached, type Answering, type Kind, type Listed, type Measured, type Order, type Ran } from '../integrations/target.ts'
-
-export type { Answering, Kind, Listed, Measured, Ran } from '../integrations/target.ts'
-
-export const CHANNEL = 'THREAD_CHANNEL'
-
-export const FOLDER = 'THREAD_FOLDER'
-
-const WAITING = 180_000
-
-const WORKING = 600_000
-
-const ASKING = '-asking'
-
-const ORDER = '-order'
-
-const ANSWER = '-answer'
-
-function overFiles(dir: string): Attached {
-  const idle = new Int32Array(new SharedArrayBuffer(4))
-  let spun = 0
-
-  const ask = (body: Order): Answer => {
-    spun += 1
-    const name = dir + '/' + String(pid) + '-' + String(spun)
-    const long = body.order === 'fetch' ? true : body.order === 'run'
-    const waits = long ? WORKING : WAITING
-    disk.writeFileSync(name + ASKING, JSON.stringify(body))
-    disk.renameSync(name + ASKING, name + ORDER)
-    const until = Date.now() + waits
-    for (;;) {
-      let held = ''
-      try {
-        held = disk.readFileSync(name + ANSWER, 'utf8')
-      } catch {
-        held = ''
-      }
-      if (held !== '') {
-        disk.rmSync(name + ANSWER, { force: true })
-        const said = JSON.parse(held) as Answer
-        if (said.answered === 'refused') throw new Error(String(said.because))
-        return said
-      }
-      if (Date.now() > until) {
-        throw new Error(
-          'nothing answered ' + body.order + ' ' + body.at + ' for ' + String(Math.round(waits / 60_000)) +
-            ' minutes, so this stopped waiting rather than spinning forever. Whoever was answering is gone. ' +
-            'Nothing here is half-written: one order is one file, and it was either answered or it was not.',
-        )
-      }
-      Atomics.wait(idle, 0, 0, 2)
-    }
-  }
-
-  const took = (body: Order): Answer => {
-    const said = ask(body)
-    const want = ORDERS[body.order]
-    if (said.answered !== want) {
-      throw new Error(
-        body.order + ' ' + body.at + ' was answered as ' + said.answered + ', and that order is answered as ' + want +
-          '. Whatever answered is not the copy of prestack this server sends orders to.',
-      )
-    }
-    return said
-  }
-
-  const kinds = new Map<string, Kind>()
-  const listed = new Map<string, readonly Listed[]>()
-  const reals = new Map<string, string>()
-
-  const listing = (at: string): readonly Listed[] => {
-    const held = listed.get(at)
-    if (held !== undefined) return held
-    const found = took({ order: 'list', at }).found as readonly Listed[]
-    listed.set(at, found)
-    return found
-  }
-
-  const kindOf = (at: string): Kind => {
-    const held = kinds.get(at)
-    if (held !== undefined) return held
-    const up = dirname(at)
-    if (up !== at && across(up)) {
-      const one = kindOf(up) === 'folder' ? listing(up).find((each) => each.name === basename(at)) : undefined
-      if (one === undefined) {
-        kinds.set(at, 'none')
-        return 'none'
-      }
-      if (one.kind !== 'other') {
-        kinds.set(at, one.kind)
-        return one.kind
-      }
-    }
-    const found = took({ order: 'kind', at }).found as Kind
-    kinds.set(at, found)
-    return found
-  }
-
-  const wrote = (at: string): void => {
-    kinds.set(at, 'file')
-    for (let child = at, up = dirname(at); up !== child && across(up); child = up, up = dirname(up)) {
-      const inside = listed.get(up)
-      if (inside !== undefined && !inside.some((each) => each.name === basename(child))) {
-        listed.set(up, [...inside, { name: basename(child), kind: child === at ? 'file' : 'folder' }])
-      }
-      kinds.set(up, 'folder')
-    }
-  }
-
-  const removed = (at: string): void => {
-    for (const key of [...kinds.keys()]) if (key.startsWith(at + '/')) kinds.delete(key)
-    for (const key of [...listed.keys()]) if (key === at || key.startsWith(at + '/')) listed.delete(key)
-    reals.clear()
-    kinds.set(at, 'none')
-    const inside = listed.get(dirname(at))
-    if (inside !== undefined) listed.set(dirname(at), inside.filter((each) => each.name !== basename(at)))
-  }
-
-  const unknown = (): void => {
-    kinds.clear()
-    listed.clear()
-    reals.clear()
-  }
-
-  return {
-    kind: kindOf,
-    read: (at) => String(took({ order: 'read', at }).said),
-    write: (at, said, mode) => {
-      took(mode === undefined ? { order: 'write', at, said } : { order: 'write', at, said, mode })
-      wrote(at)
-    },
-    list: listing,
-    stat: (at) => took({ order: 'stat', at }).found as Measured,
-    remove: (at) => {
-      took({ order: 'remove', at })
-      removed(at)
-    },
-    real: (at) => {
-      const held = reals.get(at)
-      if (held !== undefined) return held
-      const found = String(took({ order: 'real', at }).at)
-      reals.set(at, found)
-      return found
-    },
-    fetch: (at, words) => {
-      try {
-        return String(took(words === undefined ? { order: 'fetch', at } : { order: 'fetch', at, words }).said)
-      } finally {
-        unknown()
-      }
-    },
-    run: (at, words) => {
-      try {
-        return took({ order: 'run', at, words }).found as Ran
-      } finally {
-        unknown()
-      }
-    },
-  }
-}
-
-const seam: { held?: Attached } = {}
-
-const WHERE = env[CHANNEL]
-
-if (WHERE !== undefined && WHERE !== '') seam.held = overFiles(WHERE)
-
-export function answeredBy(one?: Attached): void {
-  seam.held = one
-}
-
-const placed = (at: string): string => {
-  const root = env[FOLDER] ?? ''
-  return root === '' ? at : resolve(root, at)
-}
-
-const within = (root: string, at: string): boolean => {
-  const step = relative(resolve(root), resolve(root, at))
-  return step === '' || (!step.startsWith('..') && !isAbsolute(step))
-}
-
-export function across(at: string): boolean {
-  const root = env[FOLDER] ?? ''
-  return seam.held !== undefined && root !== '' && within(root, at)
-}
-
-export function beyond(at: string): boolean {
-  const root = env[FOLDER] ?? ''
-  return seam.held !== undefined && root !== '' && !within(root, at)
-}
-
-function asked(at: unknown): Attached | undefined {
-  const one = seam.held
-  if (one === undefined) return undefined
-  const root = env[FOLDER] ?? ''
-  if (root === '') return typeof at === 'string' ? one : undefined
-  if (typeof at !== 'string') {
-    throw new Error('a path given as anything but text cannot be held to ' + root + ', the folder this answers for, so it was not used.')
-  }
-  if (within(root, at)) return one
-  throw new Error(
-    at + ' is outside ' + root + ', the folder this answers for. A command answering for a folder on another machine ' +
-      'reaches that folder and nothing else, so nothing was read, written or removed.',
-  )
-}
-
-export function attached(): boolean {
-  return seam.held !== undefined
-}
-
-export function here(): Attached {
-  return seam.held ?? HERE
-}
-
-export function kind(at: string): Kind {
-  const one = asked(at)
-  return one === undefined ? HERE.kind(at) : one.kind(placed(at))
-}
-
-export function existsSync(at: disk.PathLike): boolean {
-  return typeof at === 'string' ? kind(at) !== 'none' : asked(at) === undefined && disk.existsSync(at)
-}
-
-export function readFileSync(at: disk.PathOrFileDescriptor, how?: BufferEncoding): string {
-  const one = asked(at)
-  return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(placed(at as string))
-}
-
-export function writeFileSync(
-  at: disk.PathOrFileDescriptor,
-  said: string,
-  how?: BufferEncoding | { readonly encoding?: BufferEncoding; readonly mode?: number },
-): void {
-  const held = how === undefined || typeof how === 'string' ? { encoding: how, mode: undefined } : how
-  const one = asked(at)
-  if (one !== undefined) {
-    one.write(placed(at as string), said, held.mode)
-    return
-  }
-  if (typeof at === 'string') disk.mkdirSync(dirname(at), { recursive: true })
-  disk.writeFileSync(at, said, { encoding: held.encoding ?? 'utf8', ...(held.mode === undefined ? {} : { mode: held.mode }) })
-}
-
-export function createFileSync(at: string, said: string): boolean {
-  if (asked(at) !== undefined) {
-    throw new Error(at + ' is on a machine that answers orders, and only a file on this machine can be created for one command alone.')
-  }
-  disk.mkdirSync(dirname(at), { recursive: true })
-  try {
-    disk.writeFileSync(at, said, { encoding: 'utf8', flag: 'wx' })
-    return true
-  } catch (thrown) {
-    if ((thrown as NodeJS.ErrnoException).code === 'EEXIST') return false
-    throw thrown
-  }
-}
-
-export interface Named {
-  readonly name: string
-  readonly isFile: () => boolean
-  readonly isDirectory: () => boolean
-}
-
-export function readdirSync(at: disk.PathLike): string[]
-export function readdirSync(at: disk.PathLike, how: { readonly withFileTypes: true }): readonly Named[]
-export function readdirSync(at: disk.PathLike, how?: { readonly withFileTypes: true }): string[] | readonly Named[] {
-  const one = asked(at)
-  if (one === undefined) return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how)
-  const held = one.list(placed(at as string))
-  return how === undefined
-    ? held.map((each) => each.name)
-    : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }))
-}
-
-export interface Held extends Named, Measured {
-  readonly mtimeMs: number
-}
-
-export function statSync(at: disk.PathLike): Held
-export function statSync(at: disk.PathLike, how: { readonly throwIfNoEntry: false }): Held | undefined
-export function statSync(at: disk.PathLike, how?: { readonly throwIfNoEntry: false }): Held | undefined {
-  const one = asked(at)
-  if (one === undefined) return (how === undefined ? disk.statSync(at) : disk.statSync(at, how)) as Held | undefined
-  const path = placed(at as string)
-  const held = one.kind(path)
-  if (held === 'none') {
-    if (how !== undefined) return undefined
-    throw new Error(`${path} is not there, so nothing can be said about it.`)
-  }
-  const measured = one.stat(path)
-  return {
-    name: path,
-    size: measured.size,
-    modified: measured.modified,
-    mtimeMs: measured.modified,
-    isFile: () => held === 'file',
-    isDirectory: () => held === 'folder',
-  }
-}
-
-export function rmSync(at: disk.PathLike, how?: disk.RmOptions): void {
-  const one = asked(at)
-  if (one === undefined) disk.rmSync(at, how)
-  else one.remove(placed(at as string))
-}
-
-export function rmdirSync(at: disk.PathLike): void {
-  const one = asked(at)
-  if (one === undefined) disk.rmdirSync(at)
-  else one.remove(placed(at as string))
-}
-
-export function renameSync(from: disk.PathLike, to: disk.PathLike): void {
-  const one = asked(from)
-  if (one === undefined) {
-    if (typeof to === 'string') disk.mkdirSync(dirname(to), { recursive: true })
-    disk.renameSync(from, to)
-    return
-  }
-  asked(to)
-  one.write(placed(to as string), one.read(placed(from as string)))
-  one.remove(placed(from as string))
-}
-
-export function appendFileSync(at: disk.PathOrFileDescriptor, said: string): void {
-  const one = asked(at)
-  if (one === undefined) {
-    disk.appendFileSync(at, said)
-    return
-  }
-  const path = placed(at as string)
-  one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`)
-}
-
-export function realpathSync(at: disk.PathLike): string {
-  const one = asked(at)
-  return one === undefined ? disk.realpathSync(at as string) : one.real(placed(at as string))
-}
-
-const FILES_ONLY = ' is on this disk, and a disk holds files. '
-
-export const HERE: Attached = {
-  kind: (at) => {
-    let held: disk.Stats | undefined
-    try {
-      held = disk.statSync(at, { throwIfNoEntry: false })
-    } catch (thrown) {
-      const code = (thrown as NodeJS.ErrnoException).code
-      if (code === 'ERR_ACCESS_DENIED' || code === 'ENAMETOOLONG') return 'none'
-      throw thrown
-    }
-    if (held === undefined) return 'none'
-    return held.isFile() ? 'file' : held.isDirectory() ? 'folder' : 'other'
-  },
-  read: (at) => disk.readFileSync(at, 'utf8'),
-  write: (at, said, mode) => {
-    disk.mkdirSync(dirname(at), { recursive: true })
-    disk.writeFileSync(at, said, { encoding: 'utf8', ...(mode === undefined ? {} : { mode }) })
-  },
-  list: (at) =>
-    disk.readdirSync(at, { withFileTypes: true }).map((one) => ({
-      name: one.name,
-      kind: one.isFile() ? 'file' : one.isDirectory() ? 'folder' : 'other',
-    })),
-  stat: (at) => {
-    const held = disk.statSync(at)
-    return { size: held.size, modified: held.mtimeMs }
-  },
-  remove: (at) => {
-    if (disk.lstatSync(at, { throwIfNoEntry: false })?.isDirectory() === true) disk.rmdirSync(at)
-    else disk.rmSync(at)
-  },
-  real: (at) => disk.realpathSync(at),
-  fetch: (at) => {
-    throw new Error(at + FILES_ONLY + 'Installing what a tree depends on happens where somebody typed the command, so it cannot be ordered of this disk.')
-  },
-  run: (at) => {
-    throw new Error(at + FILES_ONLY + 'A program is started where somebody typed the command, so running one cannot be ordered of this disk.')
-  },
-}
-
-const GONE = 'is not in the scenario this trial stands, and while it runs the scenario is the whole tree.'
-
-const MADE_UP = 'a trial answers orders against a tree it made up, so there is nowhere here to '
-
-export function standing(root: string, given: ReadonlyMap<string, string>): Attached {
-  const flat = (at: string): string => {
-    let path = at
-    while (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1)
-    return path
-  }
-  const under = (at: string): boolean => at.startsWith(root) || `${at}/` === root
-  const own = (at: string): boolean => under(at) && !at.slice(root.length).split('/').includes('node_modules')
-  const beside = (at: string): readonly Listed[] => {
-    try {
-      return HERE.list(at)
-    } catch {
-      return []
-    }
-  }
-
-  const held = new Map<string, string>(given)
-  const folders = new Set<string>()
-  const parents = (at: string): void => {
-    for (let up = dirname(at); under(`${up}/`); up = dirname(up)) folders.add(up)
-  }
-  for (const at of held.keys()) parents(at)
-
-  const answers: Answering = {
-    kind: (at) => (held.has(at) ? 'file' : folders.has(at) ? 'folder' : own(at) ? 'none' : HERE.kind(at)),
-    read: (at) => {
-      const said = held.get(at)
-      if (said !== undefined) return said
-      if (own(at)) throw new Error(`${at} ${GONE}`)
-      return HERE.read(at)
-    },
-    write: (at, said) => {
-      held.set(at, said)
-      parents(at)
-    },
-    list: (at) => {
-      const inside = new Map<string, Listed>()
-      const found = own(at) ? [] : folders.has(at) ? beside(at) : HERE.list(at)
-      for (const one of found) inside.set(one.name, { name: one.name, kind: one.kind === 'folder' ? 'folder' : 'file' })
-      for (const path of folders) if (dirname(path) === at) inside.set(basename(path), { name: basename(path), kind: 'folder' })
-      for (const path of held.keys()) if (dirname(path) === at) inside.set(basename(path), { name: basename(path), kind: 'file' })
-      return [...inside.values()]
-    },
-    stat: (at) => {
-      const said = held.get(at)
-      if (said !== undefined) return { size: said.length, modified: 0 }
-      if (folders.has(at)) return { size: 0, modified: 0 }
-      if (own(at)) throw new Error(`${at} ${GONE}`)
-      return HERE.stat(at)
-    },
-    remove: (at) => {
-      held.delete(at)
-      folders.delete(at)
-    },
-    real: (at) => (own(at) || held.has(at) || folders.has(at) ? at : HERE.real(at)),
-  }
-
-  return {
-    kind: (at) => answers.kind(flat(at)),
-    read: (at) => answers.read(flat(at)),
-    write: (at, said) => {
-      answers.write(flat(at), said)
-    },
-    list: (at) => answers.list(flat(at)),
-    stat: (at) => answers.stat(flat(at)),
-    remove: (at) => {
-      answers.remove(flat(at))
-    },
-    real: (at) => answers.real(flat(at)),
-    fetch: () => {
-      throw new Error(MADE_UP + 'install anything into.')
-    },
-    run: () => {
-      throw new Error(MADE_UP + 'run anything in.')
-    },
-  }
-}

package/dist/integrations/generators/read.ts

@@ -1,127 +0,0 @@
-import { argv, stdout } from 'node:process'
-
-import { exit } from '../../core/invoked.ts'
-import { descend, type Row } from '../../core/descend.ts'
-import { THING as TYPED } from '../../core/scope.ts'
-
-const words = argv.slice(2).filter((one) => !one.startsWith('-'))
-
-const looking = words.join(' ').trim().toLowerCase()
-
-const pass = descend()
-
-const said = (one: Row): string => (one.describes ?? '').replace(/\s+/g, ' ')
-
-const carries = (one: Row, list: string, file: string): boolean => {
-  if (looking === '') return true
-  const held = [one.id ?? '', one.at ?? '', said(one), one.by ?? '', one.runs ?? '', list, file, ...(one.requires ?? []), ...(one.takes ?? [])]
-  return held.some((each) => each.toLowerCase().includes(looking))
-}
-
-const shown = (one: Row, list: string, pad: string, alone = false): readonly string[] => {
-  const marks = [
-    ...(one.by === undefined ? [] : [`${list === 'stated' ? 'answers' : 'written by'} \`${one.by}\``]),
-    ...(one.runs === undefined ? [] : [`checked by \`${one.runs}\``]),
-    ...((one.requires ?? []).length === 0 ? [] : [`requires ${(one.requires ?? []).join(', ')}`]),
-    ...((one.takes ?? []).length === 0 ? [] : [`takes ${(one.takes ?? []).join(', ')}`]),
-  ]
-  const sentence = said(one)
-  return [
-    `${pad}${one.id ?? '(unnamed)'}  [${list}]`,
-    ...(marks.length === 0 ? [] : [`${pad}  ${marks.join(' · ')}`]),
-
-    ...(sentence === ''
-      ? []
-      : [`${pad}  ${alone || sentence.length <= 160 ? sentence : `${sentence.slice(0, 157)}...`}`]),
-  ]
-}
-
-const files = [...pass.threaded.keys()].sort()
-
-const matched =
-  files.reduce((sum, file) => sum + (pass.threaded.get(file) ?? []).filter((each) => carries(each.row, each.list, file)).length, 0) +
-  [...pass.stated.entries()].filter(
-    ([, one]) =>
-      !files.some((file) => (pass.threaded.get(file) ?? []).some((each) => each.row === one)) && carries(one, 'stated', one.at ?? ''),
-  ).length
-
-const only = matched === 1
-
-let rows = 0
-const out: string[] = []
-
-if (looking === '') {
-  for (const file of files) {
-    const held = pass.threaded.get(file) ?? []
-    if (held.length === 0) continue
-    rows += held.length
-    out.push(`  ${String(held.length).padStart(4)}  ${file}`)
-  }
-  out.unshift(`${String(files.length)} sheet(s) in this tree, and what each holds:`, '')
-  out.push(
-    '',
-    'Name a word to read the rows themselves — every row whose id, sentence, path, command or',
-    'requirement carries it, each with what it means:',
-    '',
-    `  ${TYPED} inspect element`,
-    `  ${TYPED} inspect variant`,
-    `  ${TYPED} inspect <any word above, or any word this tree coins>`,
-    '',
-  )
-  stdout.write(`${out.join('\n')}\n`)
-  stdout.write(
-    `read: ${String(rows)} row(s) across ${String(pass.declarations)} declaration(s), ` +
-      `and ${String(pass.findings.length)} finding(s) the gate would report.\n`,
-  )
-  exit(0)
-}
-
-for (const file of files) {
-  const held = (pass.threaded.get(file) ?? []).filter((each) => carries(each.row, each.list, file))
-  if (held.length === 0) continue
-  out.push(file)
-  for (const each of held) {
-    rows += 1
-    out.push(...shown(each.row, each.list, '  ', only))
-  }
-  out.push('')
-}
-
-const loose = [...pass.stated.entries()]
-  .filter(([, one]) => !files.some((file) => (pass.threaded.get(file) ?? []).some((each) => each.row === one)))
-  .filter(([, one]) => carries(one, 'stated', one.at ?? ''))
-
-if (loose.length > 0) {
-  out.push('stated outright, in no parent\'s list')
-  for (const [, one] of loose) {
-    rows += 1
-    out.push(...shown(one, 'stated', '  ', only))
-  }
-  out.push('')
-}
-
-if (looking !== '') {
-  const coined = [...pass.coined.entries()].filter(([word]) => word.toLowerCase().includes(looking))
-  if (coined.length > 0) {
-    out.push('words this tree coins')
-    for (const [word, held] of coined) out.push(`  ${word} — declared under ${held.under}`)
-    out.push('')
-  }
-}
-
-stdout.write(`${out.join('\n')}\n`)
-
-if (rows === 0) {
-  stdout.write(
-    looking === ''
-      ? 'read: this tree declares nothing yet. Attach a package with `thread attach`.\n'
-      : `read: nothing in this tree carries "${looking}" — not an id, a sentence, a path, a command, a requirement or a thing taken.\n`,
-  )
-  exit(0)
-}
-
-stdout.write(
-  `read: ${String(rows)} row(s)${looking === '' ? '' : ` carrying "${looking}"`} across ` +
-    `${String(pass.declarations)} declaration(s), and ${String(pass.findings.length)} finding(s) the gate would report.\n`,
-)
-exit(0)