@prestack/thread 0.0.2 → 0.1.0

package/dist/core/{asking.ts → answers.ts}

@@ -1,5 +1,5 @@
 import { createHash, randomBytes } from 'node:crypto'
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, rmSync, writeFileSync } from './files.ts'
 import { tmpdir } from 'node:os'
 import { dirname, join, relative } from 'node:path'
 import { argv, env, exit, stderr, stdin, stdout } from 'node:process'
@@ -8,11 +8,9 @@ import { pathToFileURL } from 'node:url'
 import { CONSTRAINTS } from '../integrity/constraint.ts'
 import type { Row } from './descend.ts'
 import { LISTS, descend, listFields, listShape, shapeFields, shapesNamed, type Field } from './descend.ts'
-import { quoted } from './rows.ts'
+import { quoted, valuesIn } from './rows.ts'
 import type { Tree } from './tree.ts'
 
-const RECEIPTS = join(tmpdir(), 'thread-create')
-
 export const RECEIPT = '--receipt'
 
 export const ENDS = '.'
@@ -135,77 +133,6 @@ export interface Said {
   readonly optional?: boolean
 }
 
-let meanings: ReadonlyMap<string, string> | undefined
-
-function coined(word: string): string | undefined {
-  if (meanings === undefined) {
-    const found = new Map<string, string>()
-    try {
-      for (const [id, held] of descend().coined) {
-        const first = held.said[0]
-        if (first !== undefined && first !== '') found.set(id, first)
-      }
-    } catch {
-      found.clear()
-    }
-    meanings = found
-  }
-  return meanings.get(word)
-}
-
-export function asksOf(
-  noun: string,
-  shape: string | readonly Field[],
-  said: Readonly<Record<string, Said>>,
-  computed: readonly string[],
-): readonly Asked[] {
-  const fields: readonly Field[] = typeof shape === 'string' ? shapeFields(shape).map((one) => ({ ...one, boolean: false })) : shape
-  if (fields.length === 0) {
-    refuse(
-      `nothing installed here states what a ${noun} is made of, so \`thread create ${noun}\` has no questions to ` +
-        `ask. It reads that from the shape a ${noun} is declared with rather than from a list kept beside it. ` +
-        'Run `npx thread attach` to see whether the package that states it is taken on.',
-    )
-  }
-
-  const spoken: Record<string, Said> = { ...said }
-  for (const one of fields) {
-    if (spoken[one.name] !== undefined || computed.includes(one.name)) continue
-    const meaning = coined(one.name) ?? (one.guide === '' ? undefined : one.guide)
-    if (meaning === undefined) continue
-    spoken[one.name] = { guide: meaning }
-  }
-
-  const mute = fields
-    .filter((one) => one.required && !computed.includes(one.name) && spoken[one.name] === undefined)
-    .map((one) => one.name)
-  if (mute.length > 0) {
-    const one = mute.length === 1
-    refuse(
-      `every ${noun} states ${mute.join(', ')}, and \`thread create ${noun}\` never asks for ${one ? 'it' : 'them'}. ` +
-        `It would write a ${noun} with no ${mute.join(' and no ')}, and tell you it worked. ` +
-        `Give ${one ? 'it' : 'each'} a sentence where this command lists what it asks, or name ${one ? 'it' : 'them'} ` +
-        'as something the command fills in.',
-    )
-  }
-
-  return Object.keys(spoken).map((one) => {
-    const told = spoken[one] as Said
-    const known = fields.find((each) => each.name === one)
-    const spare = told.optional ?? (known !== undefined && !known.required)
-    return {
-      at: one,
-      guide: known?.boolean === true ? `${told.guide} — yes or no` : told.guide,
-      ...(told.asks === undefined ? {} : { asks: told.asks }),
-      ...(spare ? { optional: true } : {}),
-      ...(known?.list === true ? { list: true } : {}),
-      ...(known?.map === true ? { map: true } : {}),
-      ...(known?.boolean === true ? { boolean: true } : {}),
-      ...(known?.worded === true ? { worded: true } : {}),
-    }
-  })
-}
-
 export const named = (all: readonly Asked[]): readonly string[] => all.map((one) => one.at)
 
 export const prompted = (one: Asked): string =>
@@ -468,8 +395,7 @@ export function seeding(kids: ReadonlyMap<string, readonly Child[]>, root: strin
         continue
       }
 
-      mkdirSync(dirname(into), { recursive: true })
-      writeFileSync(into, one.body.endsWith('\n') ? one.body : `${one.body}\n`, 'utf8')
+        writeFileSync(into, one.body.endsWith('\n') ? one.body : `${one.body}\n`, 'utf8')
       said.push(`wrote ${one.at} with the body you gave it.`)
     }
   }
@@ -580,21 +506,20 @@ export async function bodied(
   return written === '' ? undefined : written
 }
 
-export function guidance(all: readonly Asked[]): readonly string[] {
-  const width = Math.max(...all.map((one) => one.at.length)) + 3
-  const under = ' '.repeat(width + 2)
-  return all.flatMap((one) => {
-    const lines = wrapped(one.optional === true ? `${one.guide.replace(/\.$/, '')}. Leave it blank and it is not stated` : one.guide, '')
-    return [`  ${`${one.at}:`.padEnd(width)}${lines[0] ?? ''}`, ...lines.slice(1).map((each) => `${under}${each}`)]
-  })
+export function only(
+  given: readonly { readonly at: number; readonly key: string; readonly value: string }[],
+  allowed: readonly string[],
+  where: string,
+): void {
+  unasked(ownAnswers(given), allowed, where)
 }
 
-export function only(
+export function unasked(
   given: readonly { readonly at: number; readonly key: string; readonly value: string }[],
   allowed: readonly string[],
   where: string,
 ): void {
-  for (const one of ownAnswers(given)) {
+  for (const one of given) {
     if (CARRIES.includes(one.key) || one.key === WRITES) continue
     if (allowed.includes(one.key)) continue
     refuse(
@@ -680,8 +605,6 @@ const citesOf = (held: unknown): readonly Told[] =>
       )
     : []
 
-const HELD = ['holds', 'declares'] as const
-
 const NAMED_SHAPE = /^[A-Za-z_][A-Za-z0-9_]*$/
 
 const rowLike = (one: unknown): one is Row =>
@@ -736,7 +659,7 @@ export async function declared(tree: Tree): Promise<ReadonlyMap<string, Declared
 
     let read: Record<string, unknown>
     try {
-      read = (await import(pathToFileURL(join(tree.at, at)).href)) as Record<string, unknown>
+      read = valuesIn(readFileSync(join(tree.at, at))) as Record<string, unknown>
     } catch {
       return
     }
@@ -747,7 +670,7 @@ export async function declared(tree: Tree): Promise<ReadonlyMap<string, Declared
         | undefined
       const lists: readonly { readonly list: string; readonly rows: readonly unknown[] }[] = Array.isArray(value)
         ? [{ list: name, rows: value }]
-        : HELD.flatMap((list) => {
+        : (['holds', 'declares'] as const).flatMap((list) => {
             const rows = node?.[list]
             return Array.isArray(rows) ? [{ list, rows }] : []
           })
@@ -845,80 +768,6 @@ export function nouns(all: readonly Row[], verb = 'create'): ReadonlyMap<string,
   return found
 }
 
-const spends = (root: string, nonce: string): string =>
-  join(RECEIPTS, `${createHash('sha256').update(root).digest('hex').slice(0, 16)}-${nonce}.txt`)
-
-const stamp = (listing: string): string => createHash('sha256').update(listing).digest('hex').slice(0, 12)
-
-function beingMade(): string {
-  const words = argv.slice(2).filter((one) => !one.startsWith('-'))
-  if (words[0] === 'create' && typeof words[1] === 'string' && words[1] !== '') return words[1]
-  const file = (argv[1] ?? '').split('\\').join('/').split('/').at(-1) ?? ''
-  return file.replace(/\.[^.]+$/, '')
-}
-
-export const SKILLS_AT = 'thread/knowledge'
-
-export function skillOf(noun: string): string {
-  return `${SKILLS_AT}/${noun}.md`
-}
-
-function readTheSkill(): readonly string[] {
-  const noun = env.THREAD_NOUN ?? beingMade()
-  if (noun === '') return []
-  return [
-    '',
-    `READ ${skillOf(noun)} BEFORE YOU WRITE ANYTHING. It is this command's own output, kept as a`,
-    'file, and it lists everything that already exists. Building a second copy of something the tree',
-    'already has is the most expensive mistake available here and it has already been made: thirteen',
-    'elements were declared in one app that every one of them already shipped.',
-    '',
-    'If that file is not there, run `npx thread skills` and it will be.',
-  ]
-}
-
-export function issue(root: string, listing: string): string {
-  const nonce = randomBytes(6).toString('hex')
-  mkdirSync(RECEIPTS, { recursive: true })
-  writeFileSync(spends(root, nonce), `${stamp(listing)}\n`, 'utf8')
-  const said = readTheSkill()
-  if (said.length > 0) stdout.write(`${said.join('\n')}\n`)
-  return nonce
-}
-
-export function spend(root: string, listing: string, offered: string | undefined, sheet: string): void {
-  if (offered === undefined || offered.startsWith('-')) {
-    refuse(
-      `\`${RECEIPT}\` was handed nothing to check. Run \`thread create\` with no arguments — it lists what is ` +
-        'here and issues a receipt to hand back.',
-    )
-  }
-  const path = spends(root, offered)
-  if (!existsSync(path)) {
-    refuse(
-      `\`${offered}\` is not a receipt this tree issued, or it has been spent already — one run per receipt. ` +
-        'Run `thread create` again and use the one it prints.',
-    )
-  }
-  let when = ''
-  try {
-    when = readFileSync(path, 'utf8').trim()
-  } catch {
-    when = ''
-  }
-
-  process.on('exit', (code) => {
-    if (code === 0) rmSync(path, { force: true })
-  })
-
-  if (when !== stamp(listing)) {
-    refuse(
-      `${sheet} has changed since that receipt was issued, so what you read is not what is here. ` +
-        'Run `thread create` again.',
-    )
-  }
-}
-
 export function asking(
   held: readonly { readonly at: number; readonly key: string; readonly value: string }[],
 ): {
@@ -1054,126 +903,7 @@ export function handed(): string | undefined {
   return stood
 }
 
-export const TYPED = 'npx thread'
-
-const folded = (said: string, pad: string, room = 92): readonly string[] => {
-  const out: string[] = []
-  let line = ''
-  for (const word of said.split(/\s+/)) {
-    if (line === '') line = word
-    else if (`${line} ${word}`.length <= room) line = `${line} ${word}`
-    else {
-      out.push(line)
-      line = word
-    }
-  }
-  if (line !== '') out.push(line)
-  return out.map((one) => `${pad}${one}`)
-}
-
-const parented = ((): readonly string[] => {
-  const one = CONSTRAINTS.find((each) => each.id === 'twice-parented')
-  if (one === undefined) {
-    return [
-      '',
-      'THIS PAGE CANNOT STATE THE RULE. It reads what may declare a file out of the `twice-parented`',
-      'rule, and no rule by that name ships any more. Whatever governs this now, it is not said here —',
-      `\`${TYPED} create rule\` lists every rule that does exist.`,
-    ]
-  }
-  return [
-    '',
-    'which one you pick is a rule rather than a preference, and a check refuses the tree over it:',
-    '',
-    `  ${one.id}`,
-    ...folded(`bans ${one.bans}.`, '    '),
-    ...folded(one.instead.replace(/^./, (each) => each.toUpperCase()), '    '),
-  ]
-})()
-
-const NEXT: Readonly<Record<string, string>> = {
-  declares: 'It writes the file from that, and nothing else runs. A file already on disk is left alone and the row simply names it.',
-  derives: `It writes NO file at \`at:\`, because the command in \`by:\` writes that one — which is why there is no ${asFlag(BODY)} here to give. If this tree has no command answering \`by:\`, that generator is declared first and ${asFlag(WRITES)} is what goes in it.`,
-  seeds: `TWO files come out of this and a different hand writes each, which is the whole reason there are two bodies. If this tree has no command answering \`by:\`, that generator is declared here too, so one run leaves the row, the generator and the file.`,
-}
-
-export const VERBS: readonly string[] = [
-  'nothing is in this tree until a row names it, and which of three lists the row sits in says who',
-  'wrote the file. Pick the one that is true and the rest of this framework follows from it:',
-  '',
-  '  declares   a person wrote it. Exactly one row may ever declare an address, and a second is',
-  '             refused: a file with two owners has two answers for where it came from and the tree',
-  '             can give neither.',
-  '  derives    a command wrote it. Delete the file, run the command again, and the same bytes come',
-  '             back. Many rows may derive one address, because a derivation owns nothing — it states',
-  '             `by:`, the command that writes it, and `runs:`, what catches it drifting.',
-  '  seeds      a command wrote the shape and a person fills in the part no machine can supply. Many',
-  '             rows may seed one address as well, and it is proved by shape rather than by bytes,',
-  '             because half of what is on disk is your own writing.',
-  '',
-  `a file in none of them is not in this app at all — \`${TYPED} descent\` names every one it reached`,
-  'and every one it did not, and nothing undeclared is compiled in or shipped.',
-  '',
-  'and the list decides what this command does next, not just what the row says. What it does next is',
-  'ASK FOR BODIES, and there are two of them, which are never the same text and never the same file:',
-  '',
-  `  ${asFlag(BODY).padEnd(10)} the body of the file the row names. A person wrote it.`,
-  `  ${asFlag(WRITES).padEnd(10)} the body of the GENERATOR — the code that writes a template into that file.`,
-  '',
-  'give each as text on the command. Neither may be taken out of a file, because a file is not a',
-  'receipt: nothing here checked it and no descent reached it. Single-quote a body that holds quotes.',
-  '',
-  'so each list takes a different set of them, and giving one where the other belongs is the mistake',
-  'this section exists to stop:',
-  '',
-  ...LISTS.flatMap((list) => {
-    const takes = [
-      ...(WRITTEN.includes(list) ? [asFlag(WRITES)] : []),
-      ...(BODIED.includes(list) ? [asFlag(BODY)] : []),
-    ]
-    const said = folded(
-      `takes ${takes.length === 0 ? 'no body at all' : takes.join(' and ')}. ${NEXT[list] ?? ''}`,
-      '             ',
-    )
-    return said.map((line, at) => (at === 0 ? `  ${list.padEnd(11)}${line.trim()}` : line))
-  }),
-  ...parented,
-]
-
-export const grows = (sheetAt: string, noun: string): readonly string[] => {
-  const shaped = noun.split('-').map((one) => `${one.slice(0, 1).toUpperCase()}${one.slice(1)}`).join('')
-  return [
-    `this is also how the CLI grows. A list of rows in ${sheetAt} becomes a command: declare`,
-    `\`export const THINGS: readonly Thing[] = []\` beside what is already there and \`${TYPED} create thing\``,
-    'answers from that moment, asking for whatever a `Thing` states and writing the row into that list.',
-    '',
-    `The same is true of what you have now: \`${TYPED} create ${noun}\` exists because ${sheetAt} declares`,
-    `\`${shaped}\`. Nothing was added to a list of commands anywhere — the CLI reads what your tree says.`,
-  ]
-}
-
-export const VALUED = 'THREAD_VALUED'
-
-export function answering(noun: string): readonly string[] {
-  return [
-    ...(env[VALUED] === '1' ? [] : [...VERBS, '']),
-    'what `new` asks. Give each answer as a flag on one command and close with the receipt:',
-    '',
-    `  ${TYPED} create ${noun} new --<answer> <value> ... ${RECEIPT} <receipt>`,
-    '',
-    'Flags need no terminal, no pipe and no file, so that form works everywhere. The two others',
-    'each need something you may not have: one answer to a line on stdin needs a shell that can',
-    'redirect, and `--answers <path>` needs a way to write the file first. Use them when you have',
-    'them; the line above is the one that never depends on it.',
-    '',
-    'Where a question repeats — a list of things, each with answers of its own — there are no',
-    'separate flag names for the inner ones. Give the group\'s own flag again to begin the next,',
-    'then its answers after it, reusing the same words. They are read in the order you write them,',
-    'and everything before the first group flag belongs to the thing itself.',
-    '',
-    'the answers, in order:',
-  ]
-}
+export const TYPED = 'thread'
 
 export const CARRIED: readonly { readonly verb: string; readonly typed: string; readonly does: string }[] = [
   { verb: 'read', typed: `${TYPED} read <row>`, does: 'prints every field a row states' },
@@ -1183,79 +913,6 @@ export const CARRIED: readonly { readonly verb: string; readonly typed: string;
 
 const elsewhere = CARRIED.map((one) => `\`${one.typed}\` ${one.does}`)
 
-export const ELSEWHERE: readonly string[] = [
-  'reading a row, changing one of its answers and taking it out are done in one place, whatever',
-  'declared it \u2014 name the row by its id or by the mark printed beside it above:',
-  '',
-  ...CARRIED.map((one) => `  ${one.typed.padEnd(40)}${one.does}`),
-]
-
-const opening = (said: string): string => said.split(/(?<=\.)\s/)[0] ?? said
-
-const article = (word: string): string => (/^[aeiou]/.test(word) ? 'an' : 'a')
-
-export function taught(noun: string, told: ReadonlyMap<string, Declared>, commands: ReadonlySet<string>): readonly string[] {
-  const one = told.get(noun)
-  const opens: readonly (readonly [string, string])[] = [
-    [`${TYPED} read <id>`, 'the row, and the file it names'],
-    [`${TYPED} create ${noun}`, 'this list again, with a fresh receipt'],
-    ...(commands.has('thread inspect')
-      ? [[`${TYPED} inspect <word>`, 'every row whose name or sentence carries the word'] as const]
-      : []),
-  ]
-  const top = one?.top
-  const siblings =
-    top === undefined
-      ? []
-      : [...told]
-          .filter(([, each]) => each.top?.id === top.id && each.describes !== '')
-          .sort(([left], [right]) => (left < right ? -1 : 1))
-  const pad = Math.max(0, ...siblings.map(([word]) => word.length)) + 3
-  return [
-    'DO NOT CREATE WHAT ALREADY EXISTS. Everything listed below is declared and yours to use. A thing',
-    'you cannot find is usually one of these under a word you have not met \u2014 read the sentences, not',
-    'the names.',
-    '',
-    'IF NOTHING FITS, SAY SO AND STOP. Do not coin a name: a name is a meaning, and a meaning is',
-    'declared rather than invented. Being told the list is short a thing is a useful answer.',
-    '',
-    'NOW GO AND OPEN ONE. A sentence is a summary, and every expensive mistake here was made from a',
-    'summary. These print the real thing, and none of them writes anything:',
-    '',
-    ...opens.map(([said, does]) => `  ${said.padEnd(30)}${does}`),
-    '',
-    ...(one === undefined || one.describes === ''
-      ? []
-      : [
-          `what ${article(noun)} ${noun} is:`,
-          '',
-          ...wrapped(one.describes, '  '),
-          ...one.cites.flatMap((said) => ['', ...wrapped(`said on ${said.on}: "${said.said}"`, '  ')]),
-          '',
-        ]),
-    ...(top === undefined || siblings.length < 2
-      ? []
-      : [
-          `${top.id} \u2014 ${opening(top.describes)}`,
-          'what it makes, and what each one is. Pick the one that is true before declaring anything:',
-          '',
-          ...siblings.flatMap(([word, each]) => {
-            const lines = wrapped(opening(each.describes), '')
-            return [`  ${word.padEnd(pad)}${lines[0] ?? ''}`, ...lines.slice(1).map((line) => `${' '.repeat(pad + 2)}${line}`)]
-          }),
-          '',
-        ]),
-  ]
-}
-
-export function reminded(noun: string | undefined): string {
-  const lists =
-    noun === undefined || noun === 'meta'
-      ? `\`${TYPED} create\` lists what this tree makes, and any noun run bare lists what exists, each with its sentence`
-      : `\`${TYPED} create ${noun}\` lists what exists, each with its sentence`
-  return `thread: before the next thing, ${lists}. Do not create what already exists, and if nothing fits, say so and stop.`
-}
-
 export function wordsIn(offered: readonly string[]): readonly string[] {
   const values = new Set([argv[argv.indexOf(RECEIPT) + 1], argv[argv.indexOf(ANSWERS) + 1], ...flagged().map((one) => one.value)])
   const words = argv.slice(2).filter((one) => !one.startsWith('-') && !values.has(one))

package/dist/core/attach.js

@@ -6,14 +6,14 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, rmSync, writeFileSync } from "./files.js";
 import { createRequire } from 'node:module';
 import { join, relative, resolve } from 'node:path';
 import { stdout } from 'node:process';
+import { LISTS } from "./descend.js";
 import { ROOT, TREE, root as rooted } from "./init.js";
 import { STATED, holdsRow, listBounds, quoted, reconciled, rowsIn, withRow, withoutRow } from "./rows.js";
 import { ours as isOurs } from "./scope.js";
-const LISTS = ['declares', 'derives', 'seeds'];
 const SHAPE = /export interface [A-Za-z0-9_]+ extends Threaded \{[\s\S]*?\n\}\n/;
 const MEMBERS = 'MEMBERS';
 const DOOR = '/attach';

package/dist/core/attach.ts

@@ -1,14 +1,13 @@
-import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, rmSync, writeFileSync } from './files.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, TREE, root as rooted } from './init.ts'
 import { STATED, holdsRow, listBounds, quoted, reconciled, rowsIn, withRow, withoutRow } from './rows.ts'
 import { ours as isOurs } from './scope.ts'
 
-const LISTS = ['declares', 'derives', 'seeds']
-
 const SHAPE = /export interface [A-Za-z0-9_]+ extends Threaded \{[\s\S]*?\n\}\n/
 
 const MEMBERS = 'MEMBERS'

package/dist/core/chain.js

@@ -1,16 +1,9 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 import { spawnSync } from 'node:child_process';
-import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { execPath } from 'node:process';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
+import { existsSync, readFileSync, readdirSync } from "./files.js";
+import { valuesIn } from "./rows.js";
 import { findTree } from "./tree.js";
 const STATING = 'derivation.ts';
 export async function generators(tree = findTree()) {
@@ -23,7 +16,7 @@ export async function generators(tree = findTree()) {
     for (const name of sheets) {
         const sheet = join(tree.dir, name);
         try {
-            const held = (await import(__rewriteRelativeImportExtension(pathToFileURL(sheet).href)));
+            const held = valuesIn(readFileSync(sheet));
             found.push(...(held.GENERATORS ?? []));
         }
         catch (thrown) {

package/dist/core/chain.ts

@@ -1,10 +1,11 @@
 import { spawnSync } from 'node:child_process'
-import { existsSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { execPath } from 'node:process'
-import { fileURLToPath, pathToFileURL } from 'node:url'
+import { fileURLToPath } from 'node:url'
 
 import type { Row } from './descend.ts'
+import { existsSync, readFileSync, readdirSync } from './files.ts'
+import { valuesIn } from './rows.ts'
 import { findTree, type Tree } from './tree.ts'
 
 const STATING = 'derivation.ts'
@@ -20,7 +21,7 @@ export async function generators(tree: Tree = findTree()): Promise<readonly Row[
   for (const name of sheets) {
     const sheet = join(tree.dir, name)
     try {
-      const held = (await import(pathToFileURL(sheet).href)) as { GENERATORS?: readonly Row[] }
+      const held = valuesIn(readFileSync(sheet)) as { GENERATORS?: readonly Row[] }
       found.push(...(held.GENERATORS ?? []))
     } catch (thrown) {
       throw new Error(

package/dist/core/client.d.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { type Kind, type Listed, type Measured } from './files.ts';
+export type Order = {
+    readonly order: 'kind';
+    readonly at: string;
+} | {
+    readonly order: 'read';
+    readonly at: string;
+} | {
+    readonly order: 'list';
+    readonly at: string;
+} | {
+    readonly order: 'stat';
+    readonly at: string;
+} | {
+    readonly order: 'remove';
+    readonly at: string;
+} | {
+    readonly order: 'real';
+    readonly at: string;
+} | {
+    readonly order: 'write';
+    readonly at: string;
+    readonly said: string;
+};
+export type Answered = {
+    readonly answered: 'kind';
+    readonly held: Kind;
+} | {
+    readonly answered: 'read';
+    readonly said: string;
+} | {
+    readonly answered: 'list';
+    readonly held: readonly Listed[];
+} | {
+    readonly answered: 'stat';
+    readonly held: Measured;
+} | {
+    readonly answered: 'written';
+} | {
+    readonly answered: 'removed';
+} | {
+    readonly answered: 'real';
+    readonly at: string;
+} | {
+    readonly answered: 'refused';
+    readonly because: string;
+};
+export declare function carry(one: Order): Answered;
+export interface Turn {
+    readonly of: string;
+    readonly orders?: readonly Order[];
+    readonly say?: string;
+    readonly done?: boolean;
+}
+export declare function talking(at: string, key: string, message: string): Promise<number>;
+export declare function run(said: readonly string[]): Promise<number>;