@prestack/thread 0.1.20 → 0.1.22

package/dist/core/attach.ts

@@ -1,613 +0,0 @@
-import { adding, installing, needing, starts } from '../integrations/cli.ts'
-import { attached, existsSync, here, readFileSync, rmSync, writeFileSync } from '../integrations/disk.ts'
-import { createRequire } from 'node:module'
-import { join, relative, resolve } from 'node:path'
-import { stdout } from 'node:process'
-
-import { LISTS } from './descend.ts'
-import { ROOT, SHAPED, TREE, root as rooted } from './init.ts'
-import { BESIDE } from './invoked.ts'
-import { STATED, holdsRow, listBounds, quoted, reconciled, rowsIn, withRow, withoutRow } from './rows.ts'
-import { idOf, installed, ours as isOurs } from './scope.ts'
-
-const SHAPE = /export interface [A-Za-z0-9_]+ extends Threaded \{[\s\S]*?\n\}\n/
-
-const MEMBERS = 'MEMBERS'
-
-const DOOR = '/attach'
-
-export const packageOf = (name: string): string =>
-  name.startsWith('@') ? name.split('/').slice(0, 2).join('/') : (name.split('/')[0] ?? name)
-
-export interface Appending {
-  readonly into: string
-  readonly list: string
-  readonly id: string
-  readonly source: string
-}
-
-export interface Writing {
-  readonly file: string
-  readonly source: string
-}
-
-export interface Attaching {
-  readonly id: string
-  readonly writes: readonly Writing[]
-  readonly declares: string
-  readonly rows?: readonly Appending[]
-
-  readonly attaches?: readonly string[]
-
-  readonly scripts?: Readonly<Record<string, string>>
-
-  readonly needs?: Readonly<Record<string, string>>
-
-  readonly ignores?: readonly string[]
-}
-
-export class UnattachableError extends Error {
-  constructor(name: string, why: string) {
-    super(`${name} ${why}. A package that attaches exports an \`ATTACH\` from \`${name.endsWith(DOOR) ? name : `${name}${DOOR}`}\`.`)
-    this.name = 'UnattachableError'
-  }
-}
-
-export class StillADependencyError extends Error {
-  constructor(name: string, of: readonly string[]) {
-    super(`${name} is still a dependency of ${of.join(', ')} — detach ${of.length === 1 ? 'it' : 'those'} first, or their rows are left pointing at nothing.`)
-    this.name = 'StillADependencyError'
-  }
-}
-
-export class StillDeclaredError extends Error {
-  constructor(name: string, theirs: readonly string[]) {
-    super(
-      `${name} writes the files this tree declares ${theirs.slice(0, 6).join(', ')}${theirs.length > 6 ? ` and ${String(theirs.length - 6)} more` : ''} in, so detaching it would leave ${theirs.length === 1 ? 'that' : 'those'} declared by nothing. ` +
-        'Remove what this app declared of its own first, or keep the package. Detaching is for a package nothing of yours is built on.',
-    )
-    this.name = 'StillDeclaredError'
-  }
-}
-
-export class DependencyRingError extends Error {
-  constructor(ring: readonly string[]) {
-    super(`${ring.join(' depends on ')} — a ring has no first package, so there is no order to attach them in.`)
-    this.name = 'DependencyRingError'
-  }
-}
-
-export class TakenFileError extends Error {
-  constructor(name: string, file: string) {
-    super(`${file} is already there and the tree does not declare \`${name}\`'s id, so another package holds that name. One file, one owner.`)
-    this.name = 'TakenFileError'
-  }
-}
-
-export class UnthreadedError extends Error {
-  constructor() {
-    super(`there is no ${TREE}/${ROOT} here — run \`thread init\` first.`)
-    this.name = 'UnthreadedError'
-  }
-}
-
-export async function attaches(into: string, name: string): Promise<boolean> {
-  try {
-    await attaching(into, name)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function shipped(spec: string, owner: string): string {
-  const rest = spec.slice(owner.length + 1)
-  const named = idOf(owner) ?? owner
-  const part = rest === DOOR.slice(1) ? named : String(rest.split('/')[0])
-  return new URL('../' + part + '/' + BESIDE('attach'), import.meta.url).href
-}
-
-async function attaching(into: string, name: string): Promise<Attaching> {
-  const spec = name.endsWith(DOOR) ? name : `${name}${DOOR}`
-  const owner = packageOf(name)
-  let held: { ATTACH?: Attaching }
-  try {
-    if (attached() && isOurs(owner)) held = (await import(shipped(spec, owner))) as { ATTACH?: Attaching }
-    else
-    held = (await import(createRequire(join(into, 'package.json')).resolve(spec))) as { ATTACH?: Attaching }
-  } catch {
-    if (!existsSync(join(into, 'node_modules', owner, 'package.json'))) {
-      throw new UnattachableError(
-        owner,
-        'is not installed here, and fetching it did not put it on disk either. Check the name — `thread attach` ' +
-          'takes the package as the registry spells it. Nothing here was changed',
-      )
-    }
-    throw new UnattachableError(
-      name,
-      name.endsWith(DOOR) ? `is named in \`attaches\` and ${owner} as installed here ships no such module` : 'exports no `attach`',
-    )
-  }
-  if (held.ATTACH === undefined) throw new UnattachableError(name, 'exports no `ATTACH`')
-  return held.ATTACH
-}
-
-export async function behind(into: string, name: string): Promise<readonly { readonly id: string; readonly says?: string }[]> {
-  let one: Attaching
-  try {
-    one = await attaching(into, pinned(name)[0])
-  } catch {
-    return []
-  }
-  const dir = resolve(into, TREE)
-  const stale: { id: string; says?: string }[] = []
-  for (const row of one.rows ?? []) {
-    const at = join(dir, row.into)
-    if (!existsSync(at)) continue
-    const text = readFileSync(at, 'utf8')
-    const where = listBounds(text, row.list)
-    if (where === undefined) continue
-    if (text.slice(where.open, where.close).includes(row.source.trim().replace(/,$/, ''))) continue
-
-    const says = /by:\s*'(thread [a-z0-9_ -]+)'/.exec(row.source)?.[1]
-    const known = says !== undefined && text.slice(where.open, where.close).includes(`by: '${says}'`)
-    stale.push(says === undefined || known ? { id: row.id } : { id: row.id, says })
-  }
-  return stale
-}
-
-function edit(at: string, change: (text: string) => string, touched: Set<string>, into: string): void {
-  const text = readFileSync(at, 'utf8')
-  const next = change(text)
-  if (next === text) return
-  writeFileSync(at, next, 'utf8')
-  touched.add(relative(into, at))
-}
-
-function acquire(into: string, owner: string): void {
-  const manifest = join(into, 'package.json')
-  const was = readFileSync(manifest, 'utf8')
-  const parsed = JSON.parse(was) as Record<string, unknown> & { dependencies?: Record<string, string> }
-  stdout.write(`thread: ${owner} is not here yet, so this is fetching it. Nothing has to be typed for that.\n`)
-  writeFileSync(manifest, `${JSON.stringify({ ...parsed, dependencies: { ...parsed.dependencies, [owner]: 'latest' } }, null, 2)}\n`, 'utf8')
-  try {
-    installing(into)
-  } catch (thrown) {
-    writeFileSync(manifest, was, 'utf8')
-    throw new Error(
-      `${owner} could not be fetched — ${thrown instanceof Error ? thrown.message : String(thrown)} package.json is as it was, so nothing here names a package that is not on disk.`,
-    )
-  }
-  const at = join(into, 'node_modules', owner, 'package.json')
-  if (!existsSync(at)) return
-  const got = (JSON.parse(readFileSync(at, 'utf8')) as { version?: string }).version
-  if (got === undefined) return
-  const now = JSON.parse(readFileSync(manifest, 'utf8')) as Record<string, unknown> & { dependencies?: Record<string, string> }
-  writeFileSync(manifest, `${JSON.stringify({ ...now, dependencies: { ...now.dependencies, [owner]: '^' + got } }, null, 2)}\n`, 'utf8')
-}
-
-const pinned = (name: string): readonly [string, string | undefined] => {
-  const cut = name.lastIndexOf('@')
-  return cut > 0 ? [name.slice(0, cut), name.slice(cut + 1)] : [name, undefined]
-}
-
-const versionAt = (at: string): string => (JSON.parse(readFileSync(at, 'utf8')) as { readonly version?: string }).version ?? ''
-
-function fetched(into: string, owner: string, wanted: string): void {
-  const spec = `${owner}@${wanted}`
-  const at = join(into, 'node_modules', owner, 'package.json')
-  const was = existsSync(at) ? versionAt(at) : ''
-  stdout.write(`thread: fetching ${spec}, so what is installed here is that release before its rows are taken on.\n`)
-  try {
-    if (attached()) here().fetch(into, [spec])
-    else {
-      const [tool, verb] = adding(into)
-      const ran = starts(tool, [verb, spec], { at: into })
-      if (!ran.ok) throw new Error(`${tool} said: ${(ran.out + ran.err).trim()}`)
-    }
-  } catch (thrown) {
-    throw new Error(`${spec} could not be fetched — ${thrown instanceof Error ? thrown.message : String(thrown)} Nothing was attached.`)
-  }
-  const now = existsSync(at) ? versionAt(at) : ''
-  if (now !== '') stdout.write(`thread: ${owner} is on ${now}${was === '' || was === now ? '' : `, up from ${was}`}.\n`)
-}
-
-export async function attach(
-  into: string,
-  name: string,
-  touched = new Set<string>(),
-  under: readonly string[] = [],
-): Promise<readonly string[]> {
-  if (under.includes(name)) throw new DependencyRingError([...under.slice(under.indexOf(name)), name])
-  const dir = resolve(into, TREE)
-  const root = join(dir, ROOT)
-  if (!existsSync(root)) throw new UnthreadedError()
-
-  const [bare, wanted] = pinned(name)
-  const owned = packageOf(bare)
-  const landed = join(into, 'node_modules', owned, 'package.json')
-  if (wanted !== undefined) fetched(into, owned, wanted)
-  else if (!existsSync(landed)) acquire(into, owned)
-  else if (under.length === 0) {
-    stdout.write(`thread: ${owned} ${versionAt(landed)} is installed here. \`thread attach ${owned}@latest\` fetches the newest release first.\n`)
-  }
-
-  const one = await attaching(into, bare)
-
-  for (const on of one.attaches ?? []) {
-    if (!(await attaches(into, on))) acquire(into, packageOf(on))
-    if (!(await attaches(into, on))) {
-      throw new UnattachableError(
-        name,
-        `must have ${on} attached before it, and fetching ${packageOf(on)} did not put it on disk. ` +
-          `${on} is named in \`attaches\` and not in dependencies, because a package that only appends a row to a file ` +
-          'another package owns would otherwise carry an npm edge it never imports',
-      )
-    }
-    await attach(into, on, touched, [...under, name])
-  }
-
-  const plan = new Map<string, string>()
-
-
-  const reshaped: string[] = []
-
-  const noticed: string[] = []
-
-  const held = readFileSync(root, 'utf8')
-  const declares = listBounds(held, 'declares')
-
-  const ours = [...one.declares.matchAll(/\bid: '([^']+)'/g)].map((found) => found[1])
-  const mine =
-    declares !== undefined &&
-    (holdsRow(held, declares, one.id) || ours.some((id) => id !== undefined && holdsRow(held, declares, id)))
-
-  const pathIn = (source: string): string | undefined => {
-    const listed = `const HELD = {\n  declares: [\n${source}\n  ],\n}\n`
-    const span = listBounds(listed, 'declares')
-    return span === undefined ? undefined : rowsIn(listed, span)[0]?.at
-  }
-
-  const clashes: { readonly id: string; readonly yours: string; readonly theirs: string }[] = []
-
-  for (const write of one.writes) {
-    const at = join(dir, write.file)
-    if (!existsSync(at)) continue
-    const there = readFileSync(at, 'utf8')
-    for (const list of LISTS) {
-      const ships = listBounds(write.source, list)
-      const where = listBounds(there, list)
-      if (ships === undefined || where === undefined) continue
-      const standing = rowsIn(there, where)
-      for (const row of rowsIn(write.source, ships)) {
-        const held = standing.find((each) => each.id === row.id)
-        if (held?.at === undefined || row.at === undefined || held.at === row.at) continue
-        if (installed(held.at)) continue
-        clashes.push({ id: row.id, yours: held.at, theirs: row.at })
-      }
-    }
-  }
-
-  for (const row of one.rows ?? []) {
-    const target = join(dir, row.into)
-    if (!existsSync(target)) continue
-    const text = readFileSync(target, 'utf8')
-    const where = listBounds(text, row.list)
-    if (where === undefined) continue
-    const held = rowsIn(text, where).find((each) => each.id === row.id)
-    const theirs = pathIn(row.source)
-    if (held?.at === undefined || theirs === undefined || held.at === theirs) continue
-    if (installed(held.at)) continue
-    clashes.push({ id: row.id, yours: held.at, theirs })
-  }
-
-  if (clashes.length > 0) {
-    throw new Error(
-      `${name} ships rows this tree already declares under the same names, pointing at different files:\n` +
-        clashes.map((one) => `  ${one.id} — you declare ${one.yours}, this package ships ${one.theirs}`).join('\n') +
-        '\nA name means one thing in a tree, so these cannot both stand. Give yours another name: declare it ' +
-        'under the new name with `thread create meta add` FIRST, and only then take the old row out with ' +
-        '`thread create meta remove`. In that order a refusal costs nothing. The other way round, a remove ' +
-        'that works followed by an add that refuses leaves your file declared by nobody. Nothing has been ' +
-        'written here.',
-    )
-  }
-
-  for (const write of one.writes) {
-    const at = join(dir, write.file)
-    if (existsSync(at) && !mine) throw new TakenFileError(name, `${TREE}/${write.file}`)
-    if (!existsSync(at)) {
-      plan.set(at, write.source)
-      continue
-    }
-    const there = readFileSync(at, 'utf8')
-    let next = reconciled(there, write.source, STATED)
-
-    const shipped = SHAPE.exec(write.source)?.[0]
-    const standing = SHAPE.exec(next)?.[0]
-    if (shipped !== undefined && standing !== undefined && shipped !== standing) {
-      next = next.replace(standing, shipped)
-      reshaped.push(write.file)
-    }
-
-    for (const list of LISTS) {
-      const ships = listBounds(write.source, list)
-      for (const row of ships === undefined ? [] : rowsIn(write.source, ships)) {
-        const body = row.source.trim().replace(/,$/, '')
-        const where = listBounds(next, list)
-        if (where === undefined) break
-        if (next.slice(where.open, where.close).includes(body)) continue
-        const without = holdsRow(next, where, row.id) ? withoutRow(next, where, row.id) : next
-        const bounds = listBounds(without, list)
-        if (bounds === undefined) break
-        next = withRow(without, bounds, row.source)
-      }
-    }
-
-    if (next !== there) plan.set(at, next)
-  }
-
-  if (declares === undefined) {
-    const ends = held.lastIndexOf('\n}')
-    plan.set(root, `${held.slice(0, ends)}\n  declares: [\n${one.declares}\n  ],${held.slice(ends)}`)
-  } else {
-
-    const listed = `const HELD = {\n  declares: [\n${one.declares}\n  ],\n}\n`
-    const span = listBounds(listed, 'declares')
-    for (const meta of span === undefined ? [] : rowsIn(listed, span)) {
-      const text = plan.get(root) ?? held
-      const where = listBounds(text, 'declares')
-      if (where === undefined) break
-      const already = rowsIn(text, where).find((row) => row.id === meta.id)
-      if (already !== undefined && already.source.trim() === meta.source.trim()) continue
-      const without = already === undefined ? text : withoutRow(text, where, meta.id)
-      const bounds = listBounds(without, 'declares')
-      if (bounds !== undefined) plan.set(root, withRow(without, bounds, meta.source))
-    }
-  }
-
-  const today = rooted(into)
-  const owns = listBounds(today, 'declares')
-  for (const grown of owns === undefined ? [] : rowsIn(today, owns)) {
-    const text = plan.get(root) ?? readFileSync(root, 'utf8')
-    const where = listBounds(text, 'declares')
-    if (where === undefined) break
-    if (holdsRow(text, where, grown.id)) continue
-    plan.set(root, withRow(text, where, grown.source))
-    noticed.push(grown.id)
-  }
-
-  const atRoot = plan.get(root) ?? readFileSync(root, 'utf8')
-  const rootList = listBounds(atRoot, 'declares')
-  const holds = new Set(rootList === undefined ? [] : rowsIn(atRoot, rootList).map((row) => row.id))
-  for (const row of one.rows ?? []) {
-    const coined = /by:\s*'thread create ([a-z0-9_-]+)'/.exec(row.source)?.[1]
-    if (coined !== undefined && holds.has(coined)) {
-
-      const waiting = (one.rows ?? []).filter((each) => {
-        const at = join(dir, each.into)
-        if (!existsSync(at)) return false
-        const text = plan.get(at) ?? readFileSync(at, 'utf8')
-        const where = listBounds(text, each.list)
-        if (where === undefined) return false
-        return !text.slice(where.open, where.close).includes(each.source.trim().replace(/,$/, ''))
-      }).length
-
-      throw new Error(
-        `${name} brings a noun called \`${coined}\`, and this tree already declares something by that name. One ` +
-          `word, one meaning: if this attached, \`thread create ${coined}\` would run the package's command and the ` +
-          `thing you declared would be reachable only by its mark.\n\n` +
-          `Take yours out with \`thread create meta remove ${coined}\` — it refuses if anything is declared under it, ` +
-          `so read it first with \`thread create meta\` and move whatever it governs. Then attach again. ` +
-          `Nothing was written.\n\n` +
-
-          `A refusal here names a command you can actually run. If the one above does not fit what you are trying ` +
-          `to do, that is a gap in this framework rather than something to work around — say so.` +
-          (waiting === 0
-            ? ''
-            : `\n\nAn attach is all or nothing, so this is also holding back everything else ${name} would have ` +
-              `delivered: ${String(waiting)} row(s) this tree does not hold at the version installed. None of that arrives until the ` +
-              `collision above is cleared, and nothing else will tell you — \`npm install\` will go on reporting this ` +
-              `tree current.`),
-      )
-    }
-  }
-
-  for (const row of one.rows ?? []) {
-    const target = join(dir, row.into)
-
-    if (!existsSync(target) && !plan.has(target)) {
-      throw new UnattachableError(name, `wants a row in ${row.into}, which is not here`)
-    }
-    const text = plan.get(target) ?? readFileSync(target, 'utf8')
-    const where = listBounds(text, row.list)
-    if (where === undefined) throw new UnattachableError(name, `wants a row in \`${row.list}\`, which ${row.into} does not export`)
-
-    if (text.slice(where.open, where.close).includes(row.source)) continue
-
-    const held = holdsRow(text, where, row.id) ? withoutRow(text, where, row.id) : text
-    const bounds = listBounds(held, row.list)
-    if (bounds === undefined) throw new UnattachableError(name, `wants a row in \`${row.list}\`, which ${row.into} does not export`)
-    plan.set(target, withRow(held, bounds, row.source))
-  }
-
-  if (one.scripts !== undefined) {
-    const manifest = join(into, 'package.json')
-    const held = readFileSync(manifest, 'utf8')
-    const parsed = JSON.parse(held) as Record<string, unknown> & { scripts?: Record<string, string> }
-    const scripts = { ...parsed.scripts }
-    let moved = false
-    for (const [name, runs] of Object.entries(one.scripts)) {
-      if (scripts[name] === runs) continue
-      scripts[name] = runs
-      moved = true
-    }
-    if (moved) plan.set(manifest, `${JSON.stringify({ ...parsed, scripts }, null, 2)}\n`)
-  }
-
-  if (one.needs !== undefined) {
-    const manifest = join(into, 'package.json')
-    const was = readFileSync(manifest, 'utf8')
-    const scripted = plan.get(manifest)
-    if (scripted !== undefined) {
-      writeFileSync(manifest, scripted, 'utf8')
-      plan.delete(manifest)
-      touched.add(relative(into, manifest))
-    }
-    let added: readonly string[]
-    try {
-      added = needing(into, one.needs)
-    } catch (thrown) {
-      writeFileSync(manifest, was, 'utf8')
-      throw new Error(`${thrown instanceof Error ? thrown.message : String(thrown)} Nothing was attached.`)
-    }
-    if (added.length > 0) {
-      touched.add(relative(into, manifest))
-      stdout.write(`thread: ${name} needs ${added.join(', ')}, so ${added.length === 1 ? 'it is' : 'they are'} in package.json now and fetched. Nothing has to be typed for that.\n`)
-    }
-  }
-
-  if (one.ignores !== undefined && one.ignores.length > 0) {
-    const at = join(into, '.gitignore')
-    const had = existsSync(at) ? readFileSync(at, 'utf8') : ''
-    const lines = had.split('\n').map((line) => line.trim())
-    const adding = one.ignores.filter((path) => !lines.includes(path))
-    if (adding.length > 0) {
-      plan.set(at, `${had === '' ? '' : had.replace(/\n*$/, '\n')}${adding.join('\n')}\n`)
-      stdout.write(`thread: ignoring ${adding.join(', ')} — written by this framework, not declared by your tree\n`)
-    }
-  }
-
-  for (const [path, text] of plan) {
-    writeFileSync(path, text, 'utf8')
-    touched.add(relative(into, path))
-  }
-
-  for (const file of reshaped) stdout.write(`thread: reshaped ${file} — what a row may state has changed\n`)
-  for (const id of noticed) stdout.write(`thread: declared ${id} — a file this app grew after \`thread init\` ran\n`)
-
-  return [...touched].sort()
-}
-
-async function dependents(into: string, name: string): Promise<readonly string[]> {
-  const root = readFileSync(join(resolve(into, TREE), ROOT), 'utf8')
-  const manifest = JSON.parse(readFileSync(join(into, 'package.json'), 'utf8')) as {
-    dependencies?: Record<string, string>
-    devDependencies?: Record<string, string>
-  }
-  const bounds = listBounds(root, 'declares')
-  if (bounds === undefined) return []
-  const found: string[] = []
-  for (const other of [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})]) {
-    if (other === name) continue
-    let held: Attaching
-    try {
-      held = await attaching(into, other)
-    } catch {
-      continue
-    }
-    if (holdsRow(root, bounds, held.id) && (held.attaches ?? []).includes(name)) found.push(other)
-  }
-  return found.sort()
-}
-
-export async function detach(into: string, name: string): Promise<readonly string[]> {
-  const dir = resolve(into, TREE)
-  const root = join(dir, ROOT)
-  if (!existsSync(root)) throw new UnthreadedError()
-
-  const of = await dependents(into, name)
-  if (of.length > 0) throw new StillADependencyError(name, of)
-
-  const one = await attaching(into, name)
-
-  const owned = new Set((one.rows ?? []).map((row) => row.id))
-  const theirs: string[] = []
-  for (const write of one.writes) {
-    const at = join(dir, write.file)
-    if (!existsSync(at)) continue
-    const text = readFileSync(at, 'utf8')
-    for (const list of [...LISTS, MEMBERS]) {
-      const where = listBounds(text, list)
-      if (where === undefined) continue
-      for (const row of rowsIn(text, where)) if (!owned.has(row.id)) theirs.push(row.id)
-    }
-  }
-  if (theirs.length > 0) throw new StillDeclaredError(name, theirs)
-
-  const touched = new Set<string>()
-
-  for (const row of one.rows ?? []) {
-    const target = join(dir, row.into)
-    if (!existsSync(target)) continue
-    edit(target, (text) => {
-      const where = listBounds(text, row.list)
-      return where === undefined ? text : withoutRow(text, where, row.id)
-    }, touched, into)
-  }
-
-  edit(root, (text) => {
-    const where = listBounds(text, 'declares')
-    return where === undefined ? text : withoutRow(text, where, one.id)
-  }, touched, into)
-
-  for (const write of one.writes) {
-    const at = join(dir, write.file)
-    if (!existsSync(at)) continue
-    const text = readFileSync(at, 'utf8')
-    const kept = [...LISTS, MEMBERS].some((list) => {
-      const where = listBounds(text, list)
-      return where !== undefined && rowsIn(text, where).length > 0
-    })
-    if (kept) continue
-    rmSync(at)
-    touched.add(relative(into, at))
-  }
-
-  return [...touched].sort()
-}
-
-const DESCRIBES =
-  'The package every tree installs first: the descent that reads a tree, the gate that checks it, and the generators every tree runs.'
-
-const CORE_SOURCE = `import type { Threaded } from '${SHAPED}'
-
-export const CORE: Threaded = {
-  id: 'core',
-  at: '_threads/core.ts',
-  describes: ${quoted(DESCRIBES)},
-  version: 1,
-  declares: [],
-}
-
-export const GENERATORS: readonly Threaded[] = []
-`
-
-const SEEDED = {
-  attaches: ['@prestack/thread/derivation/attach', '@prestack/thread/integrations/attach', '@prestack/thread/integrity/attach', '@prestack/thread/knowledge/attach', '@prestack/thread/operations/attach'] as const,
-  id: 'core',
-  declares: [
-    '    {',
-    '      id: \'core\',',
-    '      at: \'_threads/core.ts\',',
-    '      describes: \'The package every tree installs first: the descent that reads a tree, the gate that checks it, and the generators every tree runs.\',',
-    '      version: 1,',
-    '    },',
-  ].join('\n'),
-}
-
-const SHIPPED: readonly { readonly into: string; readonly list: string; readonly id: string; readonly source: string }[] = [
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'commit',
-    source: "  {\n    id: 'commit',\n    at: 'node_modules/@prestack/thread/dist/core/generators/commit.js',\n    describes: 'Commits every change in this app, so a create or an edit leaves a mark in version control without anyone typing a git command. Unlike `cl_commit`, which runs real git to record a release on the machine the command runs on, this writes the commit in the node the command already runs in, so it works inside the permission fence an attached app runs behind, where no program may be started. It stages what changed, records it under the message it is given, and starts a repository the first time there is none. Pushing and undoing stay deliberate.',\n    version: 1,\n    by: 'thread commit',\n  },",
-  },
-]
-export const ATTACH: Attaching = {
-  attaches: SEEDED.attaches,
-  id: SEEDED.id,
-  declares: SEEDED.declares,
-  writes: [{ file: 'core.ts', source: CORE_SOURCE }],
-  rows: SHIPPED,
-}