@prestack/thread 0.0.1 → 0.0.2

package/dist/core/init.ts

@@ -0,0 +1,170 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+
+import { quoted } from './rows.ts'
+
+export const TREE = '_threads'
+export const ROOT = 'thread.ts'
+
+export class AlreadyThreadedError extends Error {
+  readonly at: string
+  constructor(at: string) {
+    super(
+
+      `${at} already exists, so this repository already has a root. A tree has one root and it is written once. ` +
+        'Declare something under it with `thread create` — run it bare to see what this tree makes — or take on ' +
+        'a package with `thread attach`, which brings its rows with it. Neither is written by hand.',
+    )
+    this.name = 'AlreadyThreadedError'
+    this.at = at
+  }
+}
+
+export const COMPILER = 'tsconfig.json'
+
+export const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'] as const
+
+export const MANIFEST = 'package.json'
+
+const MODULE = 'module'
+
+export const REGISTRY = '.npm' + 'rc'
+
+export const IGNORED = '.git' + 'ignore'
+
+export function ignored(): string {
+  return [
+    'node_' + 'modules/',
+    '.next/',
+    'dist/',
+
+    '*.tsbuildinfo',
+
+    'next-env.d.ts',
+    '.DS_Store',
+    '',
+  ].join('\n')
+}
+
+export function compiler(): string {
+  return `${JSON.stringify(
+    {
+      compilerOptions: {
+        target: 'ES2022',
+        module: 'ESNext',
+        moduleResolution: 'bundler',
+        strict: true,
+
+        allowImportingTsExtensions: true,
+
+        skipLibCheck: true,
+
+        types: ['node'],
+        jsx: 'react-jsx',
+        noEmit: true,
+      },
+    },
+    null,
+    2,
+  )}\n`
+}
+
+function owned(into: string): readonly { readonly id: string; readonly at: string; readonly describes: string; readonly runs?: string }[] {
+  const held = LOCKFILES.filter((one) => existsSync(join(into, one)))
+  return [
+    {
+      id: 'manifest',
+      at: 'package.json',
+      describes:
+        'What this app is made of and what may be run against it — the packages it installs and the commands that build it, serve it and refuse it.',
+    },
+
+    ...(existsSync(join(into, REGISTRY))
+      ? [
+          {
+            id: 'registry',
+            at: REGISTRY,
+            describes:
+              'Which registry this app’s packages come from, and any credential scoped to it. Declared beside the lockfile because an install is not reproducible without it: the lockfile says which versions answered, and this says who answered.',
+          },
+        ]
+      : []),
+    {
+      id: 'ignored',
+      at: IGNORED,
+      describes:
+        'What is built rather than written, so the checks that read this repository can tell the two apart. Every surface here asks which files are tracked, and without it an app that has been served once answers with its whole build cache.',
+    },
+    ...held.map((one) => ({
+      id: 'lockfile',
+      at: one,
+      describes:
+        'The exact version of every package this app resolved to, so an install here and an install anywhere else are the same install.',
+    })),
+  ]
+}
+
+export function root(into: string): string {
+  const rows = owned(into).flatMap((one) => [
+    '    {',
+    `      id: ${quoted(one.id)},`,
+    `      at: ${quoted(one.at)},`,
+    `      describes: ${quoted(one.describes)},`,
+    '      version: 1,',
+    ...(one.runs === undefined ? [] : [`      runs: ${quoted(one.runs)},`]),
+    '    },',
+  ])
+  return [
+    "import type { Threaded } from './thread.ts'",
+    '',
+    'export const THREAD: Threaded = {',
+    "  id: 'thread',",
+    `  at: '${TREE}/${ROOT}',`,
+    "  describes: 'The framework that declares what must exist, forbids what is not declared, and derives what can be derived.',",
+    '  version: 1,',
+    '  declares: [',
+    ...rows,
+    '  ],',
+    '}',
+    '',
+  ].join('\n')
+}
+
+export function init(into: string): readonly string[] {
+  const dir = resolve(into, TREE)
+  const at = join(dir, ROOT)
+  if (existsSync(at)) throw new AlreadyThreadedError(relative(into, at))
+  mkdirSync(dir, { recursive: true })
+  const written: string[] = []
+
+  const held = join(into, COMPILER)
+  if (!existsSync(held)) {
+    writeFileSync(held, compiler(), 'utf8')
+    written.push(COMPILER)
+  }
+
+  const manifest = join(into, MANIFEST)
+  if (!existsSync(manifest)) {
+    throw new Error(
+      `there is no ${MANIFEST} here, and a thread tree is source this package has to be able to load. ` +
+        'Run `npm init` first, then `thread init` — the tree is written beside a manifest, not instead of one.',
+    )
+  }
+  const stated = JSON.parse(readFileSync(manifest, 'utf8')) as { type?: string }
+  if (stated.type !== MODULE) {
+    writeFileSync(manifest, `${JSON.stringify({ ...stated, type: MODULE }, null, 2)}\n`, 'utf8')
+    written.push(MANIFEST)
+  }
+
+  const ignore = join(into, IGNORED)
+  if (!existsSync(ignore)) {
+    writeFileSync(ignore, ignored(), 'utf8')
+    written.push(IGNORED)
+  }
+
+  for (const [name, text] of [[ROOT, root(into)]] as const) {
+    writeFileSync(join(dir, name), text, 'utf8')
+    written.push(relative(into, join(dir, name)))
+  }
+  return written
+}

package/dist/core/invoked.ts

@@ -0,0 +1,47 @@
+import { realpathSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { argv, exit as ending } from 'node:process'
+import { fileURLToPath } from 'node:url'
+
+export function invoked(url: string): boolean {
+  const named = argv[1]
+  if (named === undefined) return false
+  try {
+    const held = new URL(url)
+    held.search = ''
+    held.hash = ''
+    return realpathSync(named) === realpathSync(fileURLToPath(held))
+  } catch {
+    return false
+  }
+}
+
+export const SOURCE = import.meta.url.endsWith('.ts')
+
+export const BESIDE = (name: string): string => `${name}${SOURCE ? '.ts' : '.js'}`
+
+export const LOADER: readonly string[] = SOURCE ? ['--import', 'tsx'] : []
+
+export const CLI: readonly string[] = [
+  ...LOADER,
+  join(dirname(fileURLToPath(import.meta.url)), BESIDE('cli')),
+]
+
+export const REFUSED = Symbol.for('thread.refused')
+
+let sharing = false
+
+export const shared = (on: boolean): void => {
+  sharing = on
+}
+
+export function exit(code?: number): never {
+  if (!sharing) ending(code)
+  throw Object.assign(new Error(`refused with ${String(code ?? 0)}`), { [REFUSED]: code ?? 0 })
+}
+
+export const refusal = (thrown: unknown): number | undefined => {
+  if (typeof thrown !== 'object' || thrown === null) return undefined
+  const held = (thrown as Record<symbol, unknown>)[REFUSED]
+  return typeof held === 'number' ? held : undefined
+}

package/dist/core/round.ts

@@ -0,0 +1,57 @@
+import { resolve } from 'node:path'
+import { argv, exitCode, stdout } from 'node:process'
+import { pathToFileURL } from 'node:url'
+
+import { generators, RAN, REFUSED_BY } from './chain.ts'
+import { forget } from './descend.ts'
+import { refusal, shared } from './invoked.ts'
+import { findTree } from './tree.ts'
+
+let spun = 0
+
+const words = (command: string): readonly string[] => command.trim().split(/\s+/).slice(1)
+
+shared(true)
+
+const tree = findTree()
+const rows = await generators(tree)
+
+for (const command of argv.slice(2).filter((one) => one !== '')) {
+  const said = words(command)
+  const name = said[0]
+  if (name === undefined) continue
+
+  const held = rows.find((one) => one.by === `thread ${name}`)
+  if (held?.at === undefined) {
+    stdout.write(`${REFUSED_BY} ${command}\n`)
+    stdout.write(`round: no command named "${name}", so \`${command}\` was not run\n`)
+    continue
+  }
+
+  const found = resolve(tree.at, held.at)
+
+  forget()
+
+  argv.length = 1
+  argv.push(found, ...said.slice(1))
+
+  spun += 1
+
+  process.exitCode = 0
+
+  try {
+    await import(`${pathToFileURL(found).href}?round=${String(spun)}`)
+    if (exitCode !== undefined && exitCode !== 0) stdout.write(`${REFUSED_BY} ${command}\n`)
+    else stdout.write(`${RAN} ${command}\n`)
+  } catch (thrown) {
+    const code = refusal(thrown)
+    if (code === undefined) {
+
+      stdout.write(`${REFUSED_BY} ${command}\n`)
+      stdout.write(`round: \`${command}\` threw: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`)
+    } else if (code === 0) stdout.write(`${RAN} ${command}\n`)
+    else stdout.write(`${REFUSED_BY} ${command}\n`)
+  }
+}
+
+process.exitCode = 0

package/dist/core/rows.ts

@@ -0,0 +1,369 @@
+import ts from 'typescript'
+
+export interface Bounds {
+  readonly open: number
+  readonly close: number
+}
+
+const PARSED = new Map<string, ts.SourceFile>()
+
+function tree(text: string): ts.SourceFile {
+  const held = PARSED.get(text)
+  if (held !== undefined) return held
+  const made = ts.createSourceFile('rows.ts', text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  if (PARSED.size > 8) PARSED.clear()
+  PARSED.set(text, made)
+  return made
+}
+
+function walk(node: ts.Node, seen: (one: ts.Node) => void): void {
+  seen(node)
+  ts.forEachChild(node, (one) => {
+    walk(one, seen)
+  })
+}
+
+const keyed = (one: ts.PropertyAssignment): string | undefined =>
+  ts.isIdentifier(one.name) || ts.isStringLiteral(one.name) ? one.name.text : undefined
+
+function stringy(node: ts.ObjectLiteralExpression, name: string): string | undefined {
+  for (const one of node.properties) {
+    if (!ts.isPropertyAssignment(one) || keyed(one) !== name) continue
+    return ts.isStringLiteral(one.initializer) ? one.initializer.text : undefined
+  }
+  return undefined
+}
+
+function listy(node: ts.ObjectLiteralExpression, name: string): ts.ArrayLiteralExpression | undefined {
+  for (const one of node.properties) {
+    if (!ts.isPropertyAssignment(one) || keyed(one) !== name) continue
+    return ts.isArrayLiteralExpression(one.initializer) ? one.initializer : undefined
+  }
+  return undefined
+}
+
+const spanned = (node: ts.Node): { readonly open: number; readonly close: number } => ({
+  open: node.getStart(),
+  close: node.getEnd() - 1,
+})
+
+export function inCode(text: string): readonly boolean[] {
+  const held = new Array<boolean>(text.length).fill(true)
+  let cursor = 0
+  while (cursor < text.length) {
+    const one = text[cursor]
+    const next = text[cursor + 1]
+    if (one === '/' && next === '/') {
+      while (cursor < text.length && text[cursor] !== '\n') held[cursor++] = false
+      continue
+    }
+    if (one === '/' && next === '*') {
+      held[cursor++] = false
+      held[cursor++] = false
+      while (cursor < text.length && !(text[cursor] === '*' && text[cursor + 1] === '/')) held[cursor++] = false
+      held[cursor++] = false
+      held[cursor++] = false
+      continue
+    }
+    if (one === "'" || one === '"' || one === '`') {
+      held[cursor++] = false
+      while (cursor < text.length && text[cursor] !== one) {
+        if (text[cursor] === '\\') held[cursor++] = false
+        held[cursor++] = false
+      }
+      held[cursor++] = false
+      continue
+    }
+    cursor += 1
+  }
+  return held
+}
+
+export function matched(text: string, code: readonly boolean[], from: number, open: string, close: string): number {
+  let depth = 0
+  for (let cursor = from; cursor < text.length; cursor += 1) {
+    if (code[cursor] !== true) continue
+    if (text[cursor] === open) depth += 1
+    if (text[cursor] === close) {
+      depth -= 1
+      if (depth === 0) return cursor
+    }
+  }
+  return -1
+}
+
+export function listBounds(text: string, list: string): Bounds | undefined {
+  const file = tree(text)
+
+  let found: ts.ArrayLiteralExpression | undefined
+  let held: ts.ObjectLiteralExpression | undefined
+
+  walk(file, (node) => {
+    if (found !== undefined || !ts.isVariableDeclaration(node) || node.initializer === undefined) return
+
+    const unwrapped = (node2: ts.Expression): ts.Expression =>
+      ts.isAsExpression(node2) || ts.isSatisfiesExpression(node2) ? unwrapped(node2.expression) : node2
+    const one = unwrapped(node.initializer)
+    if (ts.isIdentifier(node.name) && node.name.text === list && ts.isArrayLiteralExpression(one)) {
+      found = one
+      return
+    }
+    if (held === undefined && ts.isObjectLiteralExpression(one)) held = one
+  })
+
+  if (found !== undefined) return spanned(found)
+  if (held === undefined) return undefined
+  const inside = listy(held, list)
+  return inside === undefined ? undefined : spanned(inside)
+}
+
+function elements(text: string, where: Bounds): readonly ts.ObjectLiteralExpression[] {
+  let found: ts.ArrayLiteralExpression | undefined
+  walk(tree(text), (node) => {
+    if (found !== undefined) return
+    if (ts.isArrayLiteralExpression(node) && node.getStart() === where.open && node.getEnd() - 1 === where.close) {
+      found = node
+    }
+  })
+  if (found === undefined) return []
+  return found.elements.filter((one): one is ts.ObjectLiteralExpression => ts.isObjectLiteralExpression(one))
+}
+
+function rowAt(text: string, where: Bounds, id: string): ts.ObjectLiteralExpression | undefined {
+  return elements(text, where).find((one) => stringy(one, 'id') === id)
+}
+
+export function holdsRow(text: string, where: Bounds, id: string): boolean {
+  return rowAt(text, where, id) !== undefined
+}
+
+export function seededAt(text: string, where: Bounds, id: string): string | undefined {
+  const held = rowAt(text, where, id)
+  if (held === undefined) return undefined
+  const seeds = listy(held, 'seeds')
+  const derives = listy(held, 'derives')
+  if (seeds !== undefined && derives !== undefined) return undefined
+  const first = (seeds ?? derives)?.elements[0]
+  if (first === undefined || !ts.isObjectLiteralExpression(first)) return undefined
+  return stringy(first, 'at')
+}
+
+export function rowsIn(
+  text: string,
+  where: Bounds,
+): readonly { readonly id: string; readonly at: string | undefined; readonly source: string }[] {
+  const found: { id: string; at: string | undefined; source: string }[] = []
+  for (const one of elements(text, where)) {
+    const id = stringy(one, 'id')
+    if (id === undefined) continue
+
+    const at = stringy(one, 'at')
+    const from = one.getStart()
+    const line = text.lastIndexOf('\n', from) + 1
+    const pad = text.slice(line, from)
+    found.push({ id, at, source: `${/^[ \t]*$/.test(pad) ? pad : ''}${text.slice(from, one.getEnd())},` })
+  }
+  return found
+}
+
+export function withRow(text: string, where: Bounds, row: string): string {
+  const held = /[ \t]*$/.exec(text.slice(0, where.close))?.[0] ?? ''
+  const before = text.slice(0, where.close - held.length)
+  const empty = before.trimEnd().endsWith('[')
+  const line = text.lastIndexOf('\n', where.open)
+  const pad = empty ? (/^[ \t]*/.exec(text.slice(line + 1))?.[0] ?? '') : held
+  return `${before}${empty ? '\n' : ''}${row}\n${pad}${text.slice(where.close)}`
+}
+
+export function withSeed(text: string, where: Bounds, id: string, seed: string): string {
+  const held = rowAt(text, where, id)
+  if (held === undefined) return text
+  if (listy(held, 'seeds') !== undefined) return text
+
+  const to = held.getEnd() - 1
+  const line = text.lastIndexOf('\n', held.getStart())
+  const pad = /^[ \t]*/.exec(text.slice(line + 1))?.[0] ?? '  '
+  const before = text.slice(0, to).trimEnd()
+  const comma = before.endsWith(',') ? '' : ','
+  return `${before}${comma}\n${pad}  seeds: [\n${seed}\n${pad}  ],\n${pad}${text.slice(to)}`
+}
+
+export function withRequires(text: string, where: Bounds, id: string, requires: readonly string[]): string | undefined {
+  const held = rowAt(text, where, id)
+  if (held === undefined) return undefined
+
+  const line = text.lastIndexOf('\n', held.getStart()) + 1
+  const pad = `${/^[ \t]*/.exec(text.slice(line))?.[0] ?? '  '}  `
+  const written = requires.length === 0 ? '' : `${pad}requires: [${requires.map((one) => `'${one}'`).join(', ')}],\n`
+
+  const propertyNamed = (name: string): ts.PropertyAssignment | undefined => {
+    for (const one of held.properties) {
+      if (ts.isPropertyAssignment(one) && keyed(one) === name) return one
+    }
+    return undefined
+  }
+
+  const already = propertyNamed('requires')
+  if (already !== undefined) {
+    const opens = text.lastIndexOf('\n', already.getStart()) + 1
+    const shut = text.indexOf('\n', already.getEnd())
+    return `${text.slice(0, opens)}${written}${text.slice(shut === -1 ? text.length : shut + 1)}`
+  }
+
+  const version = propertyNamed('version')
+  if (version === undefined) return undefined
+  const after = text.indexOf('\n', version.getEnd())
+  const at = after === -1 ? text.length : after + 1
+  return `${text.slice(0, at)}${written}${text.slice(at)}`
+}
+
+export function seedsIn(text: string, where: Bounds, id: string): Bounds | undefined {
+  const held = rowAt(text, where, id)
+  if (held === undefined) return undefined
+  const list = listy(held, 'seeds')
+  return list === undefined ? undefined : spanned(list)
+}
+
+export function afterRow(text: string, where: Bounds, follows: string, row: string): string | undefined {
+  const held = rowAt(text, where, follows)
+  if (held === undefined) return undefined
+  let to = held.getEnd()
+  if (text[to] === ',') to += 1
+  return `${text.slice(0, to)}\n${row}${text.slice(to)}`
+}
+
+function headed(text: string): ts.ObjectLiteralExpression | undefined {
+  let found: ts.ObjectLiteralExpression | undefined
+  walk(tree(text), (node) => {
+    if (found !== undefined || !ts.isVariableDeclaration(node) || node.initializer === undefined) return
+    const one = ts.isAsExpression(node.initializer) ? node.initializer.expression : node.initializer
+    if (ts.isObjectLiteralExpression(one)) found = one
+  })
+  return found
+}
+
+function stated(node: ts.ObjectLiteralExpression, field: string): Bounds | undefined {
+  for (const one of node.properties) {
+    if (!ts.isPropertyAssignment(one) || keyed(one) !== field) continue
+    return { open: one.initializer.getStart(), close: one.initializer.getEnd() }
+  }
+  return undefined
+}
+
+export const quoted = (one: string): string => `'${one.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`
+
+export const STATED = ['at', 'describes', 'version']
+
+export function reconciled(held: string, source: string, fields: readonly string[]): string {
+  const ships = headed(source)
+  if (ships === undefined) return held
+  const named = stringy(ships, 'id')
+
+  let next = held
+  for (const field of fields) {
+    const want = stated(ships, field)
+    if (want === undefined) continue
+
+    const mine = headed(next)
+    if (mine === undefined || stringy(mine, 'id') !== named) return held
+    const have = stated(mine, field)
+    if (have === undefined) continue
+    const said = source.slice(want.open, want.close)
+    if (next.slice(have.open, have.close) === said) continue
+    next = next.slice(0, have.open) + said + next.slice(have.close)
+  }
+  return next
+}
+
+export function fieldIn(text: string, where: Bounds, id: string, field: string): string | undefined {
+  const held = rowAt(text, where, id)
+  if (held === undefined) return undefined
+  for (const one of held.properties) {
+    if (!ts.isPropertyAssignment(one) || keyed(one) !== field) continue
+    return text.slice(one.initializer.getStart(), one.initializer.getEnd())
+  }
+  return undefined
+}
+
+export function withField(
+  text: string,
+  where: Bounds,
+  id: string,
+  field: string,
+  value: string,
+): string | undefined {
+  const held = rowAt(text, where, id)
+  if (held === undefined) return undefined
+  for (const one of held.properties) {
+    if (!ts.isPropertyAssignment(one) || keyed(one) !== field) continue
+    return `${text.slice(0, one.initializer.getStart())}${value}${text.slice(one.initializer.getEnd())}`
+  }
+
+  const last = held.properties.at(-1)
+  if (last === undefined) return undefined
+
+  let ends = last.getEnd()
+  if (text[ends] === ',') ends += 1
+  const already = text[ends - 1] === ',' ? '' : ','
+
+  if (!text.slice(held.getStart(), held.getEnd()).includes('\n')) {
+    return `${text.slice(0, ends)}${already} ${field}: ${value}${text.slice(ends)}`
+  }
+
+  const line = text.lastIndexOf('\n', last.getStart()) + 1
+  const pad = /^[ \t]*/.exec(text.slice(line))?.[0] ?? '  '
+  return `${text.slice(0, ends)}${already}\n${pad}${field}: ${value},${text.slice(ends)}`
+}
+
+export function withoutRow(text: string, where: Bounds, id: string): string {
+  const held = rowAt(text, where, id)
+  if (held === undefined) return text
+  let ends = held.getEnd()
+  if (text[ends] === ',') ends += 1
+  const pad = /[ \t]*$/.exec(text.slice(0, held.getStart()))?.[0] ?? ''
+  const from = held.getStart() - pad.length
+  if (text[ends] === '\n') ends += 1
+  const left = text.slice(0, from)
+  const right = text.slice(ends)
+  return left.trimEnd().endsWith('[') && right.trimStart().startsWith(']')
+    ? `${left.replace(/\s*$/, '')}${right.replace(/^\s*/, '')}`
+    : left + right
+}
+
+const lines = (held: unknown, pad: string): readonly string[] => {
+  if (held === null || held === undefined) return [String(held)]
+  if (Array.isArray(held)) {
+    if (held.length === 0) return ['[]']
+    if (held.every((one) => typeof one !== 'object' || one === null)) return [held.map((one) => String(one)).join(', ')]
+    return held.flatMap((one) => {
+      const [first = '', ...rest] = lines(one, `${pad}  `)
+      return [`${pad}- ${first.trimStart()}`, ...rest]
+    })
+  }
+  if (typeof held === 'object') {
+    const parts = Object.entries(held as Record<string, unknown>)
+    if (parts.length === 0) return ['{}']
+    return parts.flatMap(([key, one]) => {
+      const [first = '', ...rest] = lines(one, `${pad}  `)
+      return rest.length === 0 && !first.includes('\n') ? [`${pad}${key}: ${first}`] : [`${pad}${key}:`, first, ...rest]
+    })
+  }
+  return [String(held)]
+}
+
+export function showing(row: object, only: readonly string[] = []): string {
+  const held = row as Record<string, unknown>
+  const keys = Object.keys(held)
+
+  const wanted = only.filter((one) => one !== '')
+  const stray = wanted.filter((one) => !keys.includes(one))
+  if (stray.length > 0) {
+    return `${stray.map((one) => `\`${one}\``).join(', ')} ${stray.length === 1 ? 'is not a field' : 'are not fields'} of this row. It states ${keys.join(', ')}\n`
+  }
+
+  const showing = wanted.length === 0 ? keys : wanted
+  return `${showing.flatMap((key) => {
+    const [first = '', ...rest] = lines(held[key], '  ')
+    return rest.length === 0 ? [`${key}: ${first.trimStart()}`] : [`${key}:`, first, ...rest]
+  }).join('\n')}\n`
+}

package/dist/core/scope.ts

@@ -0,0 +1,18 @@
+export const ORGANISATION = '@prestack'
+
+export const THING = 'thread'
+
+export const NAMED = `${ORGANISATION}/${THING}`
+
+const CORE = 'core'
+
+const HEAD = `${NAMED}-`
+
+export const named = (id: string): string => (id === CORE ? NAMED : `${HEAD}${id}`)
+
+export const idOf = (name: string): string | undefined => {
+  if (name === NAMED) return CORE
+  return name.startsWith(HEAD) ? name.slice(HEAD.length) : undefined
+}
+
+export const ours = (name: string): boolean => idOf(name) !== undefined

package/dist/core/thread.ts

@@ -0,0 +1,29 @@
+export interface Quote {
+  readonly on: string
+  readonly said: string
+}
+
+export interface Threaded {
+  readonly id: string
+  readonly at: string
+  readonly describes: string
+  readonly version?: number
+  readonly cites?: readonly Quote[]
+  readonly requires?: readonly string[]
+  readonly takes?: readonly string[]
+  readonly by?: string
+  readonly runs?: string
+  readonly declares?: readonly Threaded[]
+  readonly derives?: readonly Threaded[]
+  readonly seeds?: readonly Threaded[]
+}
+
+export interface Member extends Threaded {
+  readonly version: number
+}
+
+export const PREFIXES = {
+  workflow: 'wf_',
+  view: 'vw_',
+  agent: 'agt_',
+} as const satisfies Readonly<Record<string, string>>