@prestack/thread 0.1.20 → 0.1.22

package/dist/core/chain.ts

@@ -1,145 +0,0 @@
-import { starts } from '../integrations/cli.ts'
-import { join } from 'node:path'
-import { execPath } from 'node:process'
-import { fileURLToPath } from 'node:url'
-
-import type { Row } from './descend.ts'
-import { existsSync, readFileSync, readdirSync } from '../integrations/disk.ts'
-import { valuesIn } from './rows.ts'
-import { findTree, type Tree } from './tree.ts'
-
-const STATING = 'derivation.ts'
-
-export async function generators(tree: Tree = findTree()): Promise<readonly Row[]> {
-  if (!existsSync(tree.dir)) return []
-
-  const sheets = readdirSync(tree.dir)
-    .filter((one) => one.endsWith('.ts'))
-    .sort((one, two) => (one === STATING ? -1 : two === STATING ? 1 : one < two ? -1 : one > two ? 1 : 0))
-
-  const found: Row[] = []
-  for (const name of sheets) {
-    const sheet = join(tree.dir, name)
-    try {
-      const held = valuesIn(readFileSync(sheet)) as { GENERATORS?: readonly Row[] }
-      found.push(...(held.GENERATORS ?? []))
-    } catch (thrown) {
-      throw new Error(
-        `${sheet} is one of the sheets where this tree states the commands it offers, and reading it threw: ` +
-          `${thrown instanceof Error ? thrown.message : String(thrown)}. A tree whose generators cannot be read ` +
-          'offers exactly what a tree declaring none offers, so everything derived from your declarations would be ' +
-          'left stale by a command reporting that it had finished. Fix that file.',
-      )
-    }
-  }
-  return found
-}
-
-export const offers = (all: readonly Row[]): ReadonlySet<string> =>
-  new Set(all.map((one) => (typeof one.by === 'string' ? one.by : '')).filter((one) => one !== ''))
-
-const ROUNDS = 4
-
-const word = (held: unknown): string => (typeof held === 'string' ? held.trim() : '')
-
-const FROM_SOURCE = import.meta.url.endsWith('.ts')
-
-const RUNNER = fileURLToPath(new URL(FROM_SOURCE ? './round.ts' : './round.js', import.meta.url))
-
-const LOADER: readonly string[] = FROM_SOURCE ? ['--import', 'tsx'] : []
-
-export const RAN = 'round: ran'
-export const REFUSED_BY = 'round: refused'
-
-export function batched(
-  at: string,
-  commands: readonly string[],
-  within?: number,
-): readonly { readonly command: string; readonly ok: boolean; readonly said: string }[] {
-  if (commands.length === 0) return []
-
-  const out = starts(execPath, [...LOADER, RUNNER, ...new Set(commands)], { at, shows: 'errors', within })
-  const lines = out.out.split('\n')
-
-  const found = new Map<string, { readonly command: string; readonly ok: boolean; readonly said: string }>()
-  let held: string[] = []
-  for (const line of lines) {
-    const mark = line.startsWith(RAN) ? RAN : line.startsWith(REFUSED_BY) ? REFUSED_BY : undefined
-    if (mark === undefined) {
-      held.push(line)
-      continue
-    }
-    const command = line.slice(mark.length).trim()
-    found.set(command, { command, ok: mark === RAN, said: held.join('\n').trim() })
-    held = []
-  }
-
-  const orphaned = held.join('\n').trim()
-  const died =
-    out.why !== ''
-      ? ` The runner itself failed to start or was stopped: ${out.why}.`
-      : out.killed !== null
-        ? ` The runner was killed by ${out.killed} after ${String(within ?? 0)} ms. The last "settle: running" line above names the command it was inside, and everything after that one is unreported rather than refused.`
-        : found.size === 0 && !out.ok
-          ? ` The runner exited ${String(out.code)} having reported nothing, so it died before the first command finished.`
-          : ''
-  let firstUnreached = true
-  return commands.map((one) => {
-    const has = found.get(one)
-    if (has !== undefined) return has
-    const why = `settle: the runner never reported on \`${one}\`, so it was not run and is not settled.${died}`
-    const said = firstUnreached && orphaned !== '' ? `${orphaned}\n${why}` : why
-    firstUnreached = false
-    return { command: one, ok: false, said }
-  })
-}
-
-const WITHIN = 300_000
-
-function batch(
-  at: string,
-  commands: readonly string[],
-): { readonly said: readonly string[]; readonly refused: readonly string[] } {
-  const all = batched(at, commands, WITHIN)
-  return {
-    said: all.map((one) => one.said).filter((one) => one !== ''),
-    refused: all.filter((one) => !one.ok).map((one) => one.command),
-  }
-}
-
-export function settling(
-  at: string,
-  all: readonly Row[],
-  skip: readonly string[] = [],
-): { readonly ran: readonly string[]; readonly unsettled: readonly string[]; readonly rounds: number } {
-  const mine = all
-    .filter((one) => word(one.by) !== '' && word(one.runs) !== '' && word(one.by) !== word(one.runs) && !skip.includes(word(one.by)))
-    .filter((one, order, every) => every.findIndex((each) => word(each.by) === word(one.by)) === order)
-
-  const ran: string[] = []
-  let round = 0
-  let before: readonly string[] | undefined
-
-  while (round < ROUNDS) {
-    round += 1
-
-    const asking = batch(at, mine.map((one) => word(one.runs))).refused
-    const unhappy = mine.filter((one) => asking.includes(word(one.runs)))
-    if (unhappy.length === 0) return { ran, unsettled: [], rounds: round }
-
-    const still = unhappy.map((one) => word(one.runs))
-    const seen = before
-    if (seen !== undefined && still.length === seen.length && still.every((one) => seen.includes(one))) {
-      return { ran, unsettled: still, rounds: round }
-    }
-    before = still
-
-    const writing = batch(at, unhappy.map((one) => word(one.by)))
-    for (const said of writing.said) ran.push(said)
-    const refused = unhappy.filter((one) => writing.refused.includes(word(one.by))).map((one) => word(one.runs))
-
-    if (refused.length === unhappy.length) return { ran, unsettled: refused, rounds: round }
-  }
-
-  return { ran, unsettled: batch(at, mine.map((one) => word(one.runs))).refused, rounds: round }
-}

package/dist/core/condition.ts

@@ -1,227 +0,0 @@
-import { ENVIRONMENT, type Actor } from './actor.ts'
-
-export const COMPARE_OPS = ['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in', 'has'] as const
-export type CompareOp = (typeof COMPARE_OPS)[number]
-
-export const AGGREGATIONS = ['count', 'sum', 'min', 'max', 'avg'] as const
-
-export const ACTOR_FACTS = ['id', 'roles', 'entitlements', ...ENVIRONMENT.map(([fact]) => fact)] as const satisfies readonly (keyof Actor)[]
-
-export const AGO = /^[1-9][0-9]*[smhd]$/
-
-export type Operand =
-  | { readonly value: string | number | boolean | null }
-  | { readonly field: string }
-  | { readonly was: string }
-  | { readonly outer: string }
-  | { readonly actor: (typeof ACTOR_FACTS)[number] }
-  | { readonly now: true }
-  | { readonly ago: string }
-  | {
-      readonly agg: {
-        readonly of: string
-        readonly how: (typeof AGGREGATIONS)[number]
-        readonly field?: string
-        readonly where?: Condition
-      }
-    }
-
-export type Condition =
-  | { readonly all: readonly Condition[] }
-  | { readonly any: readonly Condition[] }
-  | { readonly not: Condition }
-  | { readonly is: Operand; readonly op: CompareOp; readonly than: Operand }
-
-export function walkOperands(condition: Condition, take: (one: Operand) => void): void {
-  if ('all' in condition) {
-    for (const one of condition.all) walkOperands(one, take)
-    return
-  }
-  if ('any' in condition) {
-    for (const one of condition.any) walkOperands(one, take)
-    return
-  }
-  if ('not' in condition) {
-    walkOperands(condition.not, take)
-    return
-  }
-  for (const side of [condition.is, condition.than]) {
-    take(side)
-    if ('agg' in side && side.agg.where !== undefined) walkOperands(side.agg.where, take)
-  }
-}
-
-export function mentionsActor(condition: Condition): boolean {
-  let found = false
-  walkOperands(condition, (one) => {
-    if ('actor' in one) found = true
-  })
-  return found
-}
-
-export function agoSeconds(ago: string): number | undefined {
-  if (!AGO.test(ago)) return undefined
-  const size = Number(ago.slice(0, -1))
-  const unit = ago.slice(-1)
-  return size * (unit === 's' ? 1 : unit === 'm' ? 60 : unit === 'h' ? 3_600 : 86_400)
-}
-
-export function satisfies(condition: Condition, actor: Actor): boolean {
-  if ('all' in condition) return condition.all.every((one) => satisfies(one, actor))
-  if ('any' in condition) return condition.any.some((one) => satisfies(one, actor))
-  if ('not' in condition) return !satisfies(condition.not, actor)
-
-  const reads = (one: Operand): unknown => {
-    if ('value' in one) return one.value
-    if ('actor' in one) return actor[one.actor]
-    return undefined
-  }
-
-  const left = reads(condition.is)
-  const right = reads(condition.than)
-  if (left === undefined || right === undefined) return false
-
-  const op = condition.op
-  if (op === 'in') return Array.isArray(right) && right.includes(left)
-  if (op === 'has') return Array.isArray(left) && left.includes(right)
-  if (op === 'eq') return left === right
-  if (op === 'neq') return left !== right
-  if (typeof left !== typeof right) return false
-  if (typeof left !== 'number' && typeof left !== 'string') return false
-  const other = right as number | string
-  if (op === 'lt') return left < other
-  if (op === 'lte') return left <= other
-  if (op === 'gt') return left > other
-  return left >= other
-}
-
-type Asked = {
-  readonly id: string
-  readonly fields: readonly string[]
-}
-
-export const CONDITION_ANSWERS = ['is', 'than', 'field', 'value', 'actor', 'ago', 'of', 'how', 'over', 'op', 'when', 'joins'] as const
-
-const OPERAND_WORDS = ['field', 'value', 'actor', 'now', 'ago', 'agg'] as const
-
-async function sided(
-  ask: (key: string, question: string) => Promise<string>,
-  say: (line: string) => void,
-  subject: Asked,
-  all: readonly Asked[],
-  which: string,
-): Promise<Operand> {
-  for (;;) {
-    const kind = await ask(which, `  ${which} — ${OPERAND_WORDS.join(', ')}: `)
-    if (kind === 'field') {
-      const id = await ask('field', `    which field — ${subject.fields.join(', ')}: `)
-      if (!subject.fields.includes(id)) {
-        say(`    "${subject.id}" declares no \`${id}\`.\n`)
-        continue
-      }
-      return { field: id }
-    }
-    if (kind === 'value') {
-      const raw = await ask('value', '    the value (text, a number, true, false, null): ')
-      if (raw === 'null') return { value: null }
-      if (raw === 'true' || raw === 'false') return { value: raw === 'true' }
-      const asNumber = Number(raw)
-      return { value: raw !== '' && Number.isFinite(asNumber) ? asNumber : raw }
-    }
-    if (kind === 'actor') {
-      const fact = await ask('actor', `    which — ${ACTOR_FACTS.join(', ')}: `)
-      if (!(ACTOR_FACTS as readonly string[]).includes(fact)) {
-        say(`    an actor has ${ACTOR_FACTS.join(', ')} and nothing else.\n`)
-        continue
-      }
-      return { actor: fact as (typeof ACTOR_FACTS)[number] }
-    }
-    if (kind === 'now') return { now: true }
-    if (kind === 'ago') {
-      const span = await ask('ago', '    how long — e.g. 30d, 12h, 15m, 45s: ')
-      if (!AGO.test(span)) {
-        say('    a span is a number and one of s, m, h, d.\n')
-        continue
-      }
-      return { ago: span }
-    }
-    if (kind === 'agg') {
-      const of = await ask('of', `    over which entity — ${all.map((one) => one.id).join(', ')}: `)
-      const target = all.find((one) => one.id === of)
-      if (target === undefined) {
-        say(`    nothing declares \`${of}\`.\n`)
-        continue
-      }
-      const how = await ask('how', `    how — ${AGGREGATIONS.join(', ')}: `)
-      if (!(AGGREGATIONS as readonly string[]).includes(how)) {
-        say(`    an aggregation is ${AGGREGATIONS.join(', ')}.\n`)
-        continue
-      }
-      if (how === 'count') return { agg: { of, how: 'count' } }
-      const over = await ask('over', `    over which field of ${of} — ${target.fields.join(', ')}: `)
-      if (!target.fields.includes(over)) {
-        say(`    "${of}" declares no \`${over}\`.\n`)
-        continue
-      }
-      return { agg: { of, how: how as 'sum' | 'min' | 'max' | 'avg', field: over } }
-    }
-    say(`  there is no side called "${kind}".\n`)
-  }
-}
-
-async function compared(
-  ask: (key: string, question: string) => Promise<string>,
-  say: (line: string) => void,
-  subject: Asked,
-  all: readonly Asked[],
-): Promise<Condition> {
-  for (;;) {
-    const is = await sided(ask, say, subject, all, 'is')
-    const op = await ask('op', `  op — ${COMPARE_OPS.join(', ')}: `)
-    if (!(COMPARE_OPS as readonly string[]).includes(op)) {
-      say(`  \`${op}\` is not a comparison this provider carries.\n`)
-      continue
-    }
-    const than = await sided(ask, say, subject, all, 'than')
-    return { is, op: op as (typeof COMPARE_OPS)[number], than }
-  }
-}
-
-export async function conditioned(
-  ask: (key: string, question: string) => Promise<string>,
-  say: (line: string) => void,
-  subject: { readonly id: string; readonly fields: readonly string[] },
-  all: readonly { readonly id: string; readonly fields: readonly string[] }[],
-): Promise<Condition | undefined> {
-  const held: Condition[] = []
-  let joiner: 'all' | 'any' = 'all'
-  for (;;) {
-    if (held.length === 0) {
-      const wanted = await ask('when', '  state a condition — y/n: ')
-      if (!wanted.toLowerCase().startsWith('y')) return undefined
-    }
-    held.push(await compared(ask, say, subject, all))
-    const next = await ask('joins', '  and, or, done: ')
-    if (next === 'done' || next === '') break
-    if (next === 'and') joiner = 'all'
-    else if (next === 'or') joiner = 'any'
-    else {
-      say('  say and, or, or done.\n')
-      break
-    }
-  }
-  if (held.length === 0) return undefined
-  const first = held[0] as Condition
-  return held.length === 1 ? first : joiner === 'all' ? { all: held } : { any: held }
-}
-
-import { quoted } from './rows.ts'
-
-export function said(one: unknown): string {
-  if (typeof one === 'string') return quoted(one)
-  if (one === null) return 'null'
-  if (typeof one === 'boolean' || typeof one === 'number') return String(one)
-  if (Array.isArray(one)) return `[${one.map((each) => said(each)).join(', ')}]`
-  if (typeof one === 'object') return `{ ${Object.entries(one).map(([key, held]) => `${key}: ${said(held)}`).join(', ')} }`
-  return String(one)
-}