@prestack/thread 0.0.1

package/dist/core/init.d.ts

@@ -0,0 +1,15 @@
+export declare const TREE = "_threads";
+export declare const ROOT = "thread.ts";
+export declare class AlreadyThreadedError extends Error {
+    readonly at: string;
+    constructor(at: string);
+}
+export declare const COMPILER = "tsconfig.json";
+export declare const LOCKFILES: readonly ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
+export declare const MANIFEST = "package.json";
+export declare const REGISTRY: string;
+export declare const IGNORED: string;
+export declare function ignored(): string;
+export declare function compiler(): string;
+export declare function root(into: string): string;
+export declare function init(into: string): readonly string[];

package/dist/core/init.js

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { quoted } from "./rows.js";
+export const TREE = '_threads';
+export const ROOT = 'thread.ts';
+export class AlreadyThreadedError extends Error {
+    at;
+    constructor(at) {
+        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'];
+export const MANIFEST = 'package.json';
+const MODULE = 'module';
+export const REGISTRY = '.npm' + 'rc';
+export const IGNORED = '.git' + 'ignore';
+export function ignored() {
+    return [
+        'node_' + 'modules/',
+        '.next/',
+        'dist/',
+        '*.tsbuildinfo',
+        'next-env.d.ts',
+        '.DS_Store',
+        '',
+    ].join('\n');
+}
+export function compiler() {
+    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) {
+    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) {
+    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) {
+    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 = [];
+    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'));
+    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)]]) {
+        writeFileSync(join(dir, name), text, 'utf8');
+        written.push(relative(into, join(dir, name)));
+    }
+    return written;
+}

package/dist/core/invoked.d.ts

@@ -0,0 +1,9 @@
+export declare function invoked(url: string): boolean;
+export declare const SOURCE: boolean;
+export declare const BESIDE: (name: string) => string;
+export declare const LOADER: readonly string[];
+export declare const CLI: readonly string[];
+export declare const REFUSED: unique symbol;
+export declare const shared: (on: boolean) => void;
+export declare function exit(code?: number): never;
+export declare const refusal: (thrown: unknown) => number | undefined;

package/dist/core/invoked.js

@@ -0,0 +1,41 @@
+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) {
+    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) => `${name}${SOURCE ? '.ts' : '.js'}`;
+export const LOADER = SOURCE ? ['--import', 'tsx'] : [];
+export const CLI = [
+    ...LOADER,
+    join(dirname(fileURLToPath(import.meta.url)), BESIDE('cli')),
+];
+export const REFUSED = Symbol.for('thread.refused');
+let sharing = false;
+export const shared = (on) => {
+    sharing = on;
+};
+export function exit(code) {
+    if (!sharing)
+        ending(code);
+    throw Object.assign(new Error(`refused with ${String(code ?? 0)}`), { [REFUSED]: code ?? 0 });
+}
+export const refusal = (thrown) => {
+    if (typeof thrown !== 'object' || thrown === null)
+        return undefined;
+    const held = thrown[REFUSED];
+    return typeof held === 'number' ? held : undefined;
+};

package/dist/core/round.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/round.js

@@ -0,0 +1,57 @@
+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 { resolve } from 'node:path';
+import { argv, exitCode, stdout } from 'node:process';
+import { pathToFileURL } from 'node:url';
+import { generators, RAN, REFUSED_BY } from "./chain.js";
+import { forget } from "./descend.js";
+import { refusal, shared } from "./invoked.js";
+import { findTree } from "./tree.js";
+let spun = 0;
+const words = (command) => 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(__rewriteRelativeImportExtension(`${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.d.ts

@@ -0,0 +1,26 @@
+export interface Bounds {
+    readonly open: number;
+    readonly close: number;
+}
+export declare function inCode(text: string): readonly boolean[];
+export declare function matched(text: string, code: readonly boolean[], from: number, open: string, close: string): number;
+export declare function listBounds(text: string, list: string): Bounds | undefined;
+export declare function holdsRow(text: string, where: Bounds, id: string): boolean;
+export declare function seededAt(text: string, where: Bounds, id: string): string | undefined;
+export declare function rowsIn(text: string, where: Bounds): readonly {
+    readonly id: string;
+    readonly at: string | undefined;
+    readonly source: string;
+}[];
+export declare function withRow(text: string, where: Bounds, row: string): string;
+export declare function withSeed(text: string, where: Bounds, id: string, seed: string): string;
+export declare function withRequires(text: string, where: Bounds, id: string, requires: readonly string[]): string | undefined;
+export declare function seedsIn(text: string, where: Bounds, id: string): Bounds | undefined;
+export declare function afterRow(text: string, where: Bounds, follows: string, row: string): string | undefined;
+export declare const quoted: (one: string) => string;
+export declare const STATED: string[];
+export declare function reconciled(held: string, source: string, fields: readonly string[]): string;
+export declare function fieldIn(text: string, where: Bounds, id: string, field: string): string | undefined;
+export declare function withField(text: string, where: Bounds, id: string, field: string, value: string): string | undefined;
+export declare function withoutRow(text: string, where: Bounds, id: string): string;
+export declare function showing(row: object, only?: readonly string[]): string;

package/dist/core/rows.js

@@ -0,0 +1,354 @@
+import ts from 'typescript';
+const PARSED = new Map();
+function tree(text) {
+    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, seen) {
+    seen(node);
+    ts.forEachChild(node, (one) => {
+        walk(one, seen);
+    });
+}
+const keyed = (one) => ts.isIdentifier(one.name) || ts.isStringLiteral(one.name) ? one.name.text : undefined;
+function stringy(node, name) {
+    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, name) {
+    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) => ({
+    open: node.getStart(),
+    close: node.getEnd() - 1,
+});
+export function inCode(text) {
+    const held = new Array(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, code, from, open, close) {
+    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, list) {
+    const file = tree(text);
+    let found;
+    let held;
+    walk(file, (node) => {
+        if (found !== undefined || !ts.isVariableDeclaration(node) || node.initializer === undefined)
+            return;
+        const unwrapped = (node2) => 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, where) {
+    let found;
+    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) => ts.isObjectLiteralExpression(one));
+}
+function rowAt(text, where, id) {
+    return elements(text, where).find((one) => stringy(one, 'id') === id);
+}
+export function holdsRow(text, where, id) {
+    return rowAt(text, where, id) !== undefined;
+}
+export function seededAt(text, where, id) {
+    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, where) {
+    const found = [];
+    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, where, row) {
+    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, where, id, seed) {
+    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, where, id, requires) {
+    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) => {
+        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, where, id) {
+    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, where, follows, row) {
+    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) {
+    let found;
+    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, field) {
+    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) => `'${one.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`;
+export const STATED = ['at', 'describes', 'version'];
+export function reconciled(held, source, fields) {
+    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, where, id, field) {
+    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, where, id, field, value) {
+    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, where, id) {
+    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, pad) => {
+    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);
+        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, only = []) {
+    const held = row;
+    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.d.ts

@@ -0,0 +1,6 @@
+export declare const ORGANISATION = "@prestack";
+export declare const THING = "thread";
+export declare const NAMED = "@prestack/thread";
+export declare const named: (id: string) => string;
+export declare const idOf: (name: string) => string | undefined;
+export declare const ours: (name: string) => boolean;

package/dist/core/scope.js

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