@prestack/thread 0.1.20 → 0.1.22

package/dist/derivation/generators/build.ts

@@ -1,371 +0,0 @@
-import { builtinModules, createRequire } from 'node:module'
-import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path'
-import { argv, cwd, stderr, stdout } from 'node:process'
-import { pathToFileURL } from 'node:url'
-
-import { build, initialize, stop, type BuildOptions, type Loader, type Plugin } from 'esbuild-wasm/esm/browser.js'
-
-import { descend, reached, type Pass } from '../../core/descend.ts'
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from '../../integrations/disk.ts'
-import { exit, invoked } from '../../core/invoked.ts'
-import { valuesIn } from '../../core/rows.ts'
-import { findTree } from '../../core/tree.ts'
-import type { Secret } from '../../integrations/secret.ts'
-import { servesBrowser, type Target } from '../../integrations/target.ts'
-
-const TREE = findTree()
-
-const ROOT = TREE.at
-
-const OUTSIDE = /(^|\/)node_modules(\/|$)/
-
-const BUILDS = 'thread build'
-
-const here = (path: string): string => relative(ROOT, path).split('\\').join('/')
-
-const LOADERS: Readonly<Record<string, Loader>> = {
-  '.ts': 'ts',
-  '.mts': 'ts',
-  '.cts': 'ts',
-  '.tsx': 'tsx',
-  '.js': 'js',
-  '.mjs': 'js',
-  '.cjs': 'js',
-  '.jsx': 'jsx',
-  '.json': 'json',
-}
-
-const TRIED = Object.keys(LOADERS)
-
-const IMPORTED = ['import', 'module', 'node', 'default']
-
-const REQUIRED = ['require', 'module', 'node', 'default']
-
-const RUNTIME = new Set(builtinModules)
-
-const WASM = createRequire(import.meta.url).resolve('esbuild-wasm/esbuild.wasm')
-
-let compiled: WebAssembly.Module | undefined
-
-const filed = (at: string): boolean => statSync(at, { throwIfNoEntry: false })?.isFile() === true
-
-const inside = (top: string, at: string): boolean => {
-  const said = relative(top, at)
-  return !said.startsWith('..') && !isAbsolute(said)
-}
-
-function located(base: string): string | undefined {
-  const found = [base, ...TRIED.map((one) => base + one), ...TRIED.map((one) => join(base, `index${one}`))].find(filed)
-  return found === undefined ? undefined : realpathSync(found)
-}
-
-function chosen(held: unknown, conditions: readonly string[]): string | undefined {
-  if (typeof held === 'string') return held
-  if (Array.isArray(held)) return held.map((one: unknown) => chosen(one, conditions)).find((one) => one !== undefined)
-  if (typeof held !== 'object' || held === null) return undefined
-  for (const [condition, one] of Object.entries(held as Readonly<Record<string, unknown>>)) {
-    if (!conditions.includes(condition)) continue
-    const found = chosen(one, conditions)
-    if (found !== undefined) return found
-  }
-  return undefined
-}
-
-function exported(held: unknown, sub: string, conditions: readonly string[]): string | undefined {
-  if (typeof held !== 'object' || held === null || Array.isArray(held) || !Object.keys(held).some((one) => one.startsWith('.'))) {
-    return sub === '.' ? chosen(held, conditions) : undefined
-  }
-  const paths = held as Readonly<Record<string, unknown>>
-  if (sub in paths) return chosen(paths[sub], conditions)
-  for (const [key, one] of Object.entries(paths)) {
-    const star = key.indexOf('*')
-    if (star === -1) continue
-    const before = key.slice(0, star)
-    const after = key.slice(star + 1)
-    if (sub.length < key.length - 1 || !sub.startsWith(before) || !sub.endsWith(after)) continue
-    return chosen(one, conditions)?.split('*').join(sub.slice(before.length, sub.length - after.length))
-  }
-  return undefined
-}
-
-function packaged(specifier: string, from: string, conditions: readonly string[], top: string): string | undefined {
-  const name = specifier.split('/').slice(0, specifier.startsWith('@') ? 2 : 1).join('/')
-  const sub = `.${specifier.slice(name.length)}`
-  for (let at = from; inside(top, at); at = dirname(at)) {
-    const root = join(at, 'node_modules', name)
-    const manifest = join(root, 'package.json')
-    if (filed(manifest)) {
-      const held = JSON.parse(readFileSync(manifest, 'utf8')) as { readonly exports?: unknown; readonly main?: unknown; readonly module?: unknown }
-      if (held.exports !== undefined) {
-        const found = exported(held.exports, sub, conditions)
-        return found === undefined ? undefined : located(join(root, found))
-      }
-      const main = typeof held.main === 'string' ? held.main : typeof held.module === 'string' ? held.module : 'index.js'
-      return located(join(root, sub === '.' ? main : sub))
-    }
-    if (at === top) return undefined
-  }
-  return undefined
-}
-
-const folder = (outside: boolean, top: string): Plugin => ({
-  name: 'thread-folder',
-  setup(held) {
-    held.onResolve({ filter: /.*/ }, (args) => {
-      const bare = !args.path.startsWith('.') && !isAbsolute(args.path)
-      if (args.path.startsWith('node:') || RUNTIME.has(args.path)) return { path: args.path, external: true, sideEffects: false }
-      if (bare && outside) return { path: args.path, external: true }
-      const conditions = args.kind === 'require-call' || args.kind === 'require-resolve' ? REQUIRED : IMPORTED
-      const path = resolve(args.resolveDir, args.path)
-      const found = bare ? packaged(args.path, args.resolveDir, conditions, top) : inside(top, path) ? located(path) : undefined
-      if (found !== undefined) return { path: found }
-      if (args.kind === 'require-call') return { path: args.path, external: true }
-      return {
-        errors: [
-          {
-            text:
-              `${args.path} is imported by ${args.importer === '' ? 'the entry' : args.importer}, and nothing in ${top} answers ` +
-              'to that name, so there is nothing to bundle in its place. A bundle reads only the folder it is built in',
-          },
-        ],
-      }
-    })
-    held.onLoad({ filter: /.*/ }, (args) => ({
-      contents: readFileSync(args.path, 'utf8'),
-      loader: LOADERS[extname(args.path)] ?? 'js',
-      resolveDir: dirname(args.path),
-    }))
-  },
-})
-
-export async function bundle(options: BuildOptions): Promise<string> {
-  compiled ??= new WebAssembly.Module(Buffer.from(readFileSync(WASM, 'latin1'), 'latin1'))
-  const hosted = globalThis as { self?: unknown }
-  hosted.self ??= globalThis
-  await initialize({ wasmModule: compiled, worker: false })
-  try {
-    const { packages, plugins, absWorkingDir = cwd(), ...rest } = options
-    const made = await build({
-      absWorkingDir,
-      ...rest,
-      bundle: true,
-      write: false,
-      plugins: [...(plugins ?? []), folder(packages === 'external', absWorkingDir)],
-    })
-    const text = made.outputFiles?.[0]?.text
-    if (text === undefined) throw new Error('the bundle came back holding no file, so there is nothing to write where it goes')
-    return text
-  } finally {
-    await stop()
-  }
-}
-
-function wanted(pass: Pass): readonly { entry: string; out: string }[] {
-
-  const owns = new Map<string, string>()
-  for (const [at, threadings] of pass.threaded) {
-    for (const one of threadings) {
-      const id = one.row.id
-      if (id !== undefined && !owns.has(id)) owns.set(id, at)
-    }
-  }
-
-  const found: { entry: string; out: string }[] = []
-  for (const [at, threadings] of pass.threaded) {
-    for (const one of threadings) {
-      if (one.list !== 'derives' || one.row.by !== BUILDS) continue
-      const entry = owns.get(one.by)
-      if (entry !== undefined) found.push({ entry, out: at })
-    }
-  }
-  return found
-}
-
-function compilers(pass: Pass): readonly string[] {
-  const found: string[] = []
-  for (const [at, threadings] of pass.threaded) {
-    for (const one of threadings) {
-      if (one.list !== 'declares' || one.row.by !== BUILDS) continue
-      if (!found.includes(at)) found.push(at)
-    }
-  }
-  return found
-}
-
-const JSX = /\.(c|m)?(t|j)sx$/
-
-function browsing(entry: string): boolean {
-  return JSX.test(entry)
-}
-
-function sheet<T>(file: string, list: string): readonly T[] {
-  const path = resolve(ROOT, `${TREE.name}/${file}`)
-  if (!existsSync(path)) return []
-  try {
-    const held = valuesIn(readFileSync(path, 'utf8')) as Record<string, readonly T[] | undefined>
-    return held[list] ?? []
-  } catch {
-    return []
-  }
-}
-
-function withheld(pass: Pass): ReadonlyMap<string, string> {
-  const targets = sheet<Target>('targets.ts', 'TARGETS')
-  if (targets.length === 0) return new Map()
-  const secrets = sheet<Secret>('secrets.ts', 'SECRETS')
-
-  const because = new Map<string, string>()
-  for (const one of targets) {
-    const said = servesBrowser(one, secrets)
-    if (said !== true) because.set(one.id, said)
-  }
-  if (because.size === 0) return new Map()
-
-  const guilty = new Map<string, string>()
-  const consider = (row: { readonly id?: string; readonly requires?: readonly string[] }): void => {
-    if (row.id === undefined || row.requires === undefined) return
-    for (const word of row.requires) {
-      const said = because.get(word)
-      if (said === undefined) continue
-      guilty.set(row.id, `\`${row.id}\` requires \`${word}\`, and that target cannot be reached from a page. ${said}`)
-    }
-  }
-  for (const one of pass.stated.values()) consider(one)
-  for (const held of pass.threaded.values()) for (const each of held) consider(each.row)
-  if (guilty.size === 0) return new Map()
-
-  const found = new Map<string, string>()
-  for (const [at, held] of pass.threaded) {
-    for (const each of held) {
-      const said = guilty.get(each.by)
-      if (said !== undefined) found.set(resolve(ROOT, at), said)
-    }
-  }
-  return found
-}
-
-function withholding(refusals: ReadonlyMap<string, string>): {
-  readonly name: string
-  readonly setup: (build: { onLoad: (opts: { filter: RegExp }, run: (args: { path: string }) => unknown) => void }) => void
-} {
-  return {
-    name: 'thread-withheld',
-    setup(build) {
-      build.onLoad({ filter: /.*/ }, (args) => {
-        const said = refusals.get(args.path)
-        if (said === undefined) return undefined
-        return {
-          errors: [
-            {
-              text:
-                `${said} This entry is JSX, so it is built for a browser, and everything a browser bundle ` +
-                'reaches is in the bundle. Move the operation behind something the page calls, or take the ' +
-                'target off its row.',
-            },
-          ],
-        }
-      })
-    },
-  }
-}
-
-function declared(): { readonly name: string; readonly setup: (build: { onLoad: (opts: { filter: RegExp }, run: (args: { path: string }) => unknown) => void }) => void } {
-  const wired = new Set(reached())
-  return {
-    name: 'thread-declared',
-    setup(held) {
-      held.onLoad({ filter: /\.(c|m)?(t|j)sx?$/ }, (args) => {
-        const path = here(args.path)
-        if (OUTSIDE.test(path) || path.startsWith('..') || wired.has(path)) return undefined
-        return {
-          errors: [
-            {
-              text:
-                `${path} is not declared — the descent from ${TREE.name}/thread.ts never reaches it, so nothing ` +
-                'in this app agreed it exists. Declare it from the row that owns it, or delete it. A file nothing ' +
-                'names cannot be part of what this app ships',
-            },
-          ],
-        }
-      })
-    },
-  }
-}
-
-async function main(): Promise<void> {
-  const pass = descend()
-  const all = wanted(pass)
-  const checking = argv.includes('--check')
-
-  const compiling: unknown[] = []
-  for (const one of compilers(pass)) {
-    const held = (await import(pathToFileURL(resolve(ROOT, one)).href)) as { plugin?: unknown }
-    if (held.plugin === undefined) {
-      stderr.write(
-        `build: ${one} is declared \`by: '${BUILDS}'\` and exports no \`plugin\`, so the build has nothing to run ` +
-          'from it. A file that says it compiles and compiles nothing is worse than one that says neither.\n',
-      )
-      exit(1)
-    }
-    compiling.push(held.plugin)
-  }
-
-  if (all.length === 0) {
-    if (checking) {
-      stdout.write(`build: nothing in ${TREE.name}/ derives a file \`by: '${BUILDS}'\`, so there is no artifact to be out of date.\n`)
-      return
-    }
-    stderr.write(
-      `build: nothing in ${TREE.name}/ derives a file \`by: '${BUILDS}'\`, so this app states no artifact to build. ` +
-        'Declare one from the row that owns the entry, and the build reads its entry from that row.\n',
-    )
-    exit(1)
-  }
-
-  for (const { entry, out } of all) {
-    const at = resolve(ROOT, out)
-    const before = checking && existsSync(at) ? readFileSync(at, 'utf8') : undefined
-
-    if (checking && before === undefined) {
-      stderr.write(`build: ${out} is declared and not on disk. Run \`${BUILDS}\` and commit what it writes.\n`)
-      exit(1)
-    }
-
-    const forBrowser = browsing(entry)
-    const refusals = forBrowser ? withheld(pass) : new Map<string, string>()
-
-    let held: string
-    try {
-      held = await bundle({
-        entryPoints: [resolve(ROOT, entry)],
-        format: 'esm',
-        platform: forBrowser ? 'browser' : 'node',
-        ...(forBrowser ? {} : { packages: 'external' as const }),
-        outfile: at,
-        plugins: [declared() as never, ...(refusals.size === 0 ? [] : [withholding(refusals) as never]), ...(compiling as never[])],
-        logLevel: 'silent',
-      })
-    } catch (thrown) {
-      stderr.write(`build: ${out} was not written — ${thrown instanceof Error ? thrown.message : String(thrown)}\n`)
-      exit(1)
-    }
-
-    if (checking) {
-      if (held !== before) {
-        stderr.write(
-          `build: ${out} is not what ${BUILDS} writes. A built artifact has no author — run \`${BUILDS}\` and commit the result.\n`,
-        )
-        exit(1)
-      }
-      stdout.write(`build: ${out} is up to date — ${String(new Set(reached()).size)} declared file(s) reachable.\n`)
-      continue
-    }
-
-    writeFileSync(at, held, 'utf8')
-    stdout.write(`build: wrote ${out} from ${entry} — ${String(new Set(reached()).size)} declared file(s) reachable.\n`)
-  }
-}
-
-if (invoked(import.meta.url)) await main()
-
-export { declared, wanted }

package/dist/derivation/generators/check.ts

@@ -1,118 +0,0 @@
-import { bodyHash, parseGenerated, type GeneratedFile } from './determinism.ts'
-
-export type CheckStatus = 'ok' | 'missing' | 'stale' | 'hand-edited' | 'orphaned'
-
-export interface FileCheck {
-  readonly path: string
-  readonly status: CheckStatus
-  readonly detail: string
-}
-
-export interface CheckReport {
-  readonly ok: boolean
-  readonly checks: readonly FileCheck[]
-}
-
-export type ReadFile = (path: string) => string | null
-
-export interface CheckOptions {
-
-  readonly previouslyGenerated?: readonly string[]
-}
-
-export function checkGenerated(
-  expected: readonly GeneratedFile[],
-  read: ReadFile,
-  options: CheckOptions = {},
-): CheckReport {
-  const checks: FileCheck[] = []
-  const expectedPaths = new Set(expected.map((file) => file.path))
-
-  for (const file of expected) {
-    const actual = read(file.path)
-
-    if (actual === null) {
-      checks.push({ path: file.path, status: 'missing', detail: 'not committed — run `thread generate`' })
-      continue
-    }
-
-    if (actual === file.contents) {
-      checks.push({ path: file.path, status: 'ok', detail: 'up to date' })
-      continue
-    }
-
-    const parsed = parseGenerated(file.path, actual)
-    if (parsed === null) {
-      checks.push({
-        path: file.path,
-        status: 'hand-edited',
-        detail: 'the generated header is gone — this file was replaced by hand',
-      })
-      continue
-    }
-
-    if (bodyHash(parsed.body) !== parsed.declaredHash) {
-      checks.push({
-        path: file.path,
-        status: 'hand-edited',
-        detail:
-          'the body no longer matches its own header hash. Move the change into ' +
-          `${parsed.source} first — regenerating will discard it.`,
-      })
-      continue
-    }
-
-    checks.push({
-      path: file.path,
-      status: 'stale',
-      detail: `out of date with ${parsed.source} — run \`thread generate\``,
-    })
-  }
-
-  for (const path of options.previouslyGenerated ?? []) {
-    if (expectedPaths.has(path)) continue
-    checks.push({
-      path,
-      status: 'orphaned',
-      detail: 'generation no longer owns this file — delete it',
-    })
-  }
-
-  const sorted = checks.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
-  return { ok: sorted.every((check) => check.status === 'ok'), checks: sorted }
-}
-
-export function formatCheckReport(report: CheckReport): string {
-  if (report.ok) return `generated output is up to date (${report.checks.length} files).`
-
-  const problems = report.checks.filter((check) => check.status !== 'ok')
-  return [
-    `${problems.length} of ${report.checks.length} generated file(s) need attention:`,
-    ...problems.map((check) => `  ${check.status.padEnd(12)} ${check.path}\n               ${check.detail}`),
-  ].join('\n')
-}
-
-export function detectHandEdits(
-  paths: readonly string[],
-  read: ReadFile,
-): readonly FileCheck[] {
-  const edited: FileCheck[] = []
-
-  for (const path of [...paths].sort()) {
-    const contents = read(path)
-    if (contents === null) continue
-
-    const parsed = parseGenerated(path, contents)
-    if (parsed === null) continue
-
-    if (bodyHash(parsed.body) !== parsed.declaredHash) {
-      edited.push({
-        path,
-        status: 'hand-edited',
-        detail: `edited by hand. The change belongs in ${parsed.source}.`,
-      })
-    }
-  }
-
-  return edited
-}

package/dist/derivation/generators/determinism.ts

@@ -1,145 +0,0 @@
-import { createHash } from 'node:crypto'
-
-import { named } from '../../core/scope.ts'
-
-export interface GeneratedFile {
-
-  readonly path: string
-
-  readonly contents: string
-}
-
-export function sortedBy<T>(items: Iterable<T>, key: (item: T) => string): T[] {
-  return [...items].sort((a, b) => compare(key(a), key(b)))
-}
-
-export function compare(a: string, b: string): number {
-  return a < b ? -1 : a > b ? 1 : 0
-}
-
-export function sortedEntries<V>(record: Readonly<Record<string, V>>): [string, V][] {
-  return Object.keys(record)
-    .sort(compare)
-    .map((key) => [key, record[key] as V])
-}
-
-const BANNER = `GENERATED by ${named('derivation')} — do not edit by hand.`
-const HASH_LABEL = 'codegen-hash:'
-
-interface HeaderSyntax {
-  readonly wrap: (text: string) => string
-  readonly unwrap: (line: string) => string | null
-}
-
-function headerSyntax(path: string): HeaderSyntax {
-  if (path.endsWith('.md')) {
-    return {
-      wrap: (text) => `<!-- ${text} -->`,
-      unwrap: (line) =>
-        line.startsWith('<!-- ') && line.endsWith(' -->') ? line.slice(5, -4) : null,
-    }
-  }
-  const prefix = path.endsWith('.sql') ? '--' : path.endsWith('.ts') || path.endsWith('.tsx') ? '//' : null
-  if (prefix === null) {
-    throw new Error(
-      `${named('derivation')} emits only .ts, .sql and .md, received "${path}". ` +
-        'A format with no comment syntax cannot carry a header, and an unheadered generated ' +
-        'file is one somebody edits by hand.',
-    )
-  }
-  return {
-    wrap: (text) => `${prefix} ${text}`,
-    unwrap: (line) => (line.startsWith(`${prefix} `) ? line.slice(prefix.length + 1) : null),
-  }
-}
-
-export function bodyHash(body: string): string {
-  return createHash('sha256').update(body, 'utf8').digest('hex')
-}
-
-const HEADER_LINES = 5
-
-export function withHeader(path: string, source: string, body: string): GeneratedFile {
-  const { wrap } = headerSyntax(path)
-  const normalized = body.endsWith('\n') ? body : `${body}\n`
-
-  const header = [
-    wrap(BANNER),
-    wrap(`Source: ${source}`),
-    wrap('Edit the island and re-run `thread generate`. CI fails when this file is stale.'),
-    wrap(`${HASH_LABEL} ${bodyHash(normalized)}`),
-    '',
-  ]
-
-  return { path, contents: `${header.join('\n')}\n${normalized}` }
-}
-
-export interface ParsedFile {
-  readonly source: string
-  readonly declaredHash: string
-  readonly body: string
-}
-
-export function parseGenerated(path: string, contents: string): ParsedFile | null {
-  let unwrap: HeaderSyntax['unwrap']
-  try {
-    unwrap = headerSyntax(path).unwrap
-  } catch {
-    return null
-  }
-  const lines = contents.split('\n')
-
-  if (unwrap(lines[0] ?? '') !== BANNER) return null
-
-  const sourceLine = unwrap(lines[1] ?? '')
-  const hashLine = unwrap(lines[3] ?? '')
-  if (sourceLine === null || !sourceLine.startsWith('Source: ')) return null
-  if (hashLine === null || !hashLine.startsWith(`${HASH_LABEL} `)) return null
-
-  return {
-    source: sourceLine.slice('Source: '.length),
-    declaredHash: hashLine.slice(HASH_LABEL.length + 1),
-    body: lines.slice(HEADER_LINES).join('\n'),
-  }
-}
-
-export function lines(...parts: readonly (string | readonly string[])[]): string {
-  return parts.flat().join('\n').replace(/[ \t]+$/gm, '')
-}
-
-export function tsString(value: string): string {
-  return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`
-}
-
-export function stableJson(value: unknown, indent = 0): string {
-  const pad = '  '.repeat(indent)
-  const padInner = '  '.repeat(indent + 1)
-
-  if (value === null) return 'null'
-  if (Array.isArray(value)) {
-    if (value.length === 0) return '[]'
-    return `[\n${value.map((item) => `${padInner}${stableJson(item, indent + 1)}`).join(',\n')}\n${pad}]`
-  }
-  if (typeof value === 'object') {
-    const keys = Object.keys(value as Record<string, unknown>).sort()
-    if (keys.length === 0) return '{}'
-    return `{\n${keys
-      .map((key) => `${padInner}${JSON.stringify(key)}: ${stableJson((value as Record<string, unknown>)[key], indent + 1)}`)
-      .join(',\n')}\n${pad}}`
-  }
-  return JSON.stringify(value)
-}
-
-export function pascal(id: string): string {
-  return id
-    .replace(/^(ent_|fld_|rel_|wf_|role_)/, '')
-    .split(/[_.]/)
-    .filter(Boolean)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join('')
-}
-
-export function camel(id: string): string {
-  const p = pascal(id)
-  return p.charAt(0).toLowerCase() + p.slice(1)
-}