@prestack/thread 0.1.2 → 0.1.4

package/dist/core/init.ts

@@ -1,8 +1,12 @@
-import { existsSync, readFileSync, writeFileSync } from './files.ts'
+import { LOCKFILES, installing, manager } from '../integrations/cli.ts'
+import { existsSync, readFileSync, writeFileSync } from '../integrations/disk.ts'
+import { createRequire } from 'node:module'
 import { join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 import { quoted } from './rows.ts'
 
+
 export const TREE = '_threads'
 export const ROOT = 'thread.ts'
 
@@ -22,19 +26,16 @@ export class AlreadyThreadedError extends Error {
 
 export const COMPILER = 'tsconfig.json'
 
-export const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'] as const
-
-export function manager(into: string): readonly string[] {
-  if (existsSync(join(into, 'pnpm-lock.yaml'))) return ['pnpm', 'add']
-  if (existsSync(join(into, 'yarn.lock'))) return ['yarn', 'add']
-  if (existsSync(join(into, 'bun.lockb'))) return ['bun', 'add']
-  return ['npm', 'install']
-}
-
 export const MANIFEST = 'package.json'
 
+const BUILT = '_gener' + 'ated/packages/core'
+
 const MODULE = 'module'
 
+const NPM = 'npm'
+
+const LATEST = 'latest'
+
 export const REGISTRY = '.npm' + 'rc'
 
 export const IGNORED = '.git' + 'ignore'
@@ -77,7 +78,7 @@ export function compiler(): string {
 }
 
 function owned(into: string): readonly { readonly id: string; readonly at: string; readonly describes: string; readonly runs?: string }[] {
-  const held = LOCKFILES.filter((one) => existsSync(join(into, one)))
+  const held = Object.keys(LOCKFILES).filter((one) => existsSync(join(into, one)))
   return [
     {
       id: 'manifest',
@@ -137,6 +138,37 @@ export function root(into: string): string {
   ].join('\n')
 }
 
+const own = createRequire(import.meta.url)
+
+function manifested(at: string): { readonly name?: string; readonly version?: string } | undefined {
+  try {
+    return own(at) as { readonly name?: string; readonly version?: string }
+  } catch {
+    return undefined
+  }
+}
+
+function shipped(): readonly [string, string] {
+  let at = fileURLToPath(new URL('.', import.meta.url))
+  for (;;) {
+    const read = manifested(join(at, MANIFEST))
+    if (read !== undefined) {
+      if (read.name !== undefined && read.version !== undefined) return [read.name, read.version]
+      const core = manifested(join(at, BUILT, MANIFEST))
+      if (core?.name !== undefined && core.version !== undefined) return [core.name, core.version]
+    }
+    const up = resolve(at, '..')
+    if (up === at) {
+      throw new Error(
+        'this framework cannot find the package it is running from, so it has no name to install into your project. ' +
+          'That name is read off the manifest beside this code rather than written down anywhere, which is what keeps it ' +
+          'right when the package is renamed.',
+      )
+    }
+    at = up
+  }
+}
+
 export function init(into: string): readonly string[] {
   const dir = resolve(into, TREE)
   const at = join(dir, ROOT)
@@ -151,10 +183,9 @@ export function init(into: string): readonly string[] {
 
   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 called = (into.split('/').filter(Boolean).pop() ?? 'app').toLowerCase().replace(/[^a-z0-9-]+/g, '-')
+    writeFileSync(manifest, JSON.stringify({ name: called, version: '0.0.0', type: MODULE }, null, 2) + '\n', 'utf8')
+    written.push(MANIFEST)
   }
   const stated = JSON.parse(readFileSync(manifest, 'utf8')) as { type?: string }
   if (stated.type !== MODULE) {
@@ -162,12 +193,24 @@ export function init(into: string): readonly string[] {
     written.push(MANIFEST)
   }
 
+  const [from, version] = shipped()
+  const holds = JSON.parse(readFileSync(manifest, 'utf8')) as { devDependencies?: Record<string, string> }
+  const dev = holds.devDependencies ?? {}
+  const wanted: Readonly<Record<string, string>> = { [from]: '^' + version, ...(manager(into) === NPM ? { [NPM]: LATEST } : {}) }
+  const missing = Object.entries(wanted).filter(([name]) => dev[name] === undefined)
+  if (missing.length > 0) {
+    writeFileSync(manifest, JSON.stringify({ ...holds, devDependencies: { ...dev, ...Object.fromEntries(missing) } }, null, 2) + '\n', 'utf8')
+    written.push(MANIFEST)
+  }
+
   const ignore = join(into, IGNORED)
   if (!existsSync(ignore)) {
     writeFileSync(ignore, ignored(), 'utf8')
     written.push(IGNORED)
   }
 
+  installing(into)
+
   for (const [name, text] of [[ROOT, root(into)]] as const) {
     writeFileSync(join(dir, name), text, 'utf8')
     written.push(relative(into, join(dir, name)))

package/dist/core/invoked.d.ts

@@ -4,6 +4,6 @@ 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 const shared: (on: boolean) => boolean;
 export declare function exit(code?: number): never;
 export declare const refusal: (thrown: unknown) => number | undefined;

package/dist/core/invoked.js

@@ -1,7 +1,7 @@
-import { realpathSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { argv, exit as ending } from 'node:process';
 import { fileURLToPath } from 'node:url';
+import { realpathSync } from '../integrations/disk.js';
 export function invoked(url) {
     const named = argv[1];
     if (named === undefined)
@@ -26,7 +26,9 @@ export const CLI = [
 export const REFUSED = Symbol.for('thread.refused');
 let sharing = false;
 export const shared = (on) => {
+    const was = sharing;
     sharing = on;
+    return was;
 };
 export function exit(code) {
     if (!sharing)

package/dist/core/invoked.ts

@@ -1,8 +1,9 @@
-import { realpathSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { argv, exit as ending } from 'node:process'
 import { fileURLToPath } from 'node:url'
 
+import { realpathSync } from '../integrations/disk.ts'
+
 export function invoked(url: string): boolean {
   const named = argv[1]
   if (named === undefined) return false
@@ -31,8 +32,10 @@ export const REFUSED = Symbol.for('thread.refused')
 
 let sharing = false
 
-export const shared = (on: boolean): void => {
+export const shared = (on: boolean): boolean => {
+  const was = sharing
   sharing = on
+  return was
 }
 
 export function exit(code?: number): never {

package/dist/core/round.js

@@ -7,17 +7,19 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { resolve } from 'node:path';
-import { argv, exitCode, stdout } from 'node:process';
+import { argv, exitCode, stderr, 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";
+import { generators, RAN, REFUSED_BY } from './chain.js';
+import { attached, here } from '../integrations/disk.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);
+let stale = true;
 for (const command of argv.slice(2).filter((one) => one !== '')) {
     const said = words(command);
     const name = said[0];
@@ -25,33 +27,45 @@ for (const command of argv.slice(2).filter((one) => one !== '')) {
         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`);
+        stdout.write(`${REFUSED_BY} ${command}\n`);
         continue;
     }
     const found = resolve(tree.at, held.at);
-    forget();
+    if (stale)
+        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`);
+    const began = Date.now();
+    stderr.write(`settle: running ${command}\n`);
+    let ok = true;
+    const ran = attached() ? here().run(found, said.slice(1)) : undefined;
+    if (ran !== undefined) {
+        stdout.write(ran.out);
+        stderr.write(ran.err);
+        ok = ran.there && ran.ok;
+        if (!ran.there)
+            stdout.write('round: ' + command + ' could not be started where the tree is: ' + ran.why + '\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 {
+        try {
+            await import(__rewriteRelativeImportExtension(`${pathToFileURL(found).href}?round=${String(spun)}`));
+            ok = exitCode === undefined || exitCode === 0;
+        }
+        catch (thrown) {
+            const code = refusal(thrown);
+            if (code === undefined) {
+                ok = false;
+                stdout.write(`round: \`${command}\` threw: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
+            }
+            else
+                ok = code === 0;
         }
-        else if (code === 0)
-            stdout.write(`${RAN} ${command}\n`);
-        else
-            stdout.write(`${REFUSED_BY} ${command}\n`);
     }
+    stdout.write(`${ok ? RAN : REFUSED_BY} ${command}\n`);
+    stderr.write(`settle: ${command} — ${String(Date.now() - began)} ms, ${ok ? 'ran' : 'refused'}\n`);
+    stale = !command.trim().endsWith('--check');
 }
 process.exitCode = 0;

package/dist/core/round.ts

@@ -1,8 +1,9 @@
 import { resolve } from 'node:path'
-import { argv, exitCode, stdout } from 'node:process'
+import { argv, exitCode, stderr, stdout } from 'node:process'
 import { pathToFileURL } from 'node:url'
 
 import { generators, RAN, REFUSED_BY } from './chain.ts'
+import { attached, here } from '../integrations/disk.ts'
 import { forget } from './descend.ts'
 import { refusal, shared } from './invoked.ts'
 import { findTree } from './tree.ts'
@@ -16,6 +17,8 @@ shared(true)
 const tree = findTree()
 const rows = await generators(tree)
 
+let stale = true
+
 for (const command of argv.slice(2).filter((one) => one !== '')) {
   const said = words(command)
   const name = said[0]
@@ -23,14 +26,14 @@ for (const command of argv.slice(2).filter((one) => one !== '')) {
 
   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`)
+    stdout.write(`${REFUSED_BY} ${command}\n`)
     continue
   }
 
   const found = resolve(tree.at, held.at)
 
-  forget()
+  if (stale) forget()
 
   argv.length = 1
   argv.push(found, ...said.slice(1))
@@ -39,19 +42,33 @@ for (const command of argv.slice(2).filter((one) => one !== '')) {
 
   process.exitCode = 0
 
+  const began = Date.now()
+  stderr.write(`settle: running ${command}\n`)
+
+  let ok = true
+  const ran = attached() ? here().run(found, said.slice(1)) : undefined
+  if (ran !== undefined) {
+    stdout.write(ran.out)
+    stderr.write(ran.err)
+    ok = ran.there && ran.ok
+    if (!ran.there) stdout.write('round: ' + command + ' could not be started where the tree is: ' + ran.why + '\n')
+  } else {
   try {
     await import(`${pathToFileURL(found).href}?round=${String(spun)}`)
-    if (exitCode !== undefined && exitCode !== 0) stdout.write(`${REFUSED_BY} ${command}\n`)
-    else stdout.write(`${RAN} ${command}\n`)
+    ok = exitCode === undefined || exitCode === 0
   } catch (thrown) {
     const code = refusal(thrown)
     if (code === undefined) {
-
-      stdout.write(`${REFUSED_BY} ${command}\n`)
+      ok = false
       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`)
+    } else ok = code === 0
+  }
   }
+
+  stdout.write(`${ok ? RAN : REFUSED_BY} ${command}\n`)
+  stderr.write(`settle: ${command} — ${String(Date.now() - began)} ms, ${ok ? 'ran' : 'refused'}\n`)
+
+  stale = !command.trim().endsWith('--check')
 }
 
 process.exitCode = 0

package/dist/core/rows.d.ts

@@ -5,6 +5,7 @@ export interface Bounds {
 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 nestedBounds(text: string, where: Bounds, parent: 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 {
@@ -24,5 +25,8 @@ 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 withTopField(text: string, field: string, value: string): string | undefined;
+export declare function withoutField(text: string, where: Bounds, id: string, field: string): string;
 export declare function withoutRow(text: string, where: Bounds, id: string): string;
+export declare function marked(parts: readonly string[]): string;
 export declare function showing(row: object, only?: readonly string[]): string;

package/dist/core/rows.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import ts from 'typescript';
 const PARSED = new Map();
 function tree(text) {
@@ -109,6 +110,13 @@ export function listBounds(text, list) {
     const inside = listy(held, list);
     return inside === undefined ? undefined : spanned(inside);
 }
+export function nestedBounds(text, where, parent, list) {
+    const row = rowAt(text, where, parent);
+    if (row === undefined)
+        return undefined;
+    const inside = listy(row, list);
+    return inside === undefined ? undefined : spanned(inside);
+}
 function elements(text, where) {
     let found;
     walk(tree(text), (node) => {
@@ -341,8 +349,26 @@ export function fieldIn(text, where, id, field) {
 }
 export function withField(text, where, id, field, value) {
     const held = rowAt(text, where, id);
-    if (held === undefined)
-        return undefined;
+    return held === undefined ? undefined : fieldOn(text, held, field, value);
+}
+export function withTopField(text, field, value) {
+    const held = headed(text);
+    return held === undefined ? undefined : fieldOn(text, held, field, value);
+}
+export function withoutField(text, where, id, field) {
+    const held = rowAt(text, where, id);
+    const one = held?.properties.find((each) => ts.isPropertyAssignment(each) && keyed(each) === field);
+    if (held === undefined || one === undefined)
+        return text;
+    let ends = one.getEnd();
+    if (text[ends] === ',')
+        ends += 1;
+    const line = text.lastIndexOf('\n', one.getStart());
+    if (line > held.getStart())
+        return text.slice(0, line) + text.slice(ends);
+    return text.slice(0, one.getStart()) + text.slice(text[ends] === ' ' ? ends + 1 : ends);
+}
+function fieldOn(text, held, field, value) {
     for (const one of held.properties) {
         if (!ts.isPropertyAssignment(one) || keyed(one) !== field)
             continue;
@@ -403,6 +429,9 @@ const lines = (held, pad) => {
     }
     return [String(held)];
 };
+export function marked(parts) {
+    return createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 6);
+}
 export function showing(row, only = []) {
     const held = row;
     const keys = Object.keys(held);

package/dist/core/rows.ts

@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto'
+
 import ts from 'typescript'
 
 export interface Bounds {
@@ -117,6 +119,13 @@ export function listBounds(text: string, list: string): Bounds | undefined {
   return inside === undefined ? undefined : spanned(inside)
 }
 
+export function nestedBounds(text: string, where: Bounds, parent: string, list: string): Bounds | undefined {
+  const row = rowAt(text, where, parent)
+  if (row === undefined) return undefined
+  const inside = listy(row, list)
+  return inside === undefined ? undefined : spanned(inside)
+}
+
 function elements(text: string, where: Bounds): readonly ts.ObjectLiteralExpression[] {
   let found: ts.ArrayLiteralExpression | undefined
   walk(tree(text), (node) => {
@@ -351,7 +360,26 @@ export function withField(
   value: string,
 ): string | undefined {
   const held = rowAt(text, where, id)
-  if (held === undefined) return undefined
+  return held === undefined ? undefined : fieldOn(text, held, field, value)
+}
+
+export function withTopField(text: string, field: string, value: string): string | undefined {
+  const held = headed(text)
+  return held === undefined ? undefined : fieldOn(text, held, field, value)
+}
+
+export function withoutField(text: string, where: Bounds, id: string, field: string): string {
+  const held = rowAt(text, where, id)
+  const one = held?.properties.find((each) => ts.isPropertyAssignment(each) && keyed(each) === field)
+  if (held === undefined || one === undefined) return text
+  let ends = one.getEnd()
+  if (text[ends] === ',') ends += 1
+  const line = text.lastIndexOf('\n', one.getStart())
+  if (line > held.getStart()) return text.slice(0, line) + text.slice(ends)
+  return text.slice(0, one.getStart()) + text.slice(text[ends] === ' ' ? ends + 1 : ends)
+}
+
+function fieldOn(text: string, held: ts.ObjectLiteralExpression, field: string, value: string): string | 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())}`
@@ -409,6 +437,10 @@ const lines = (held: unknown, pad: string): readonly string[] => {
   return [String(held)]
 }
 
+export function marked(parts: readonly string[]): string {
+  return createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 6)
+}
+
 export function showing(row: object, only: readonly string[] = []): string {
   const held = row as Record<string, unknown>
   const keys = Object.keys(held)

package/dist/core/thread.d.ts

@@ -20,7 +20,7 @@ export interface Member extends Threaded {
     readonly version: number;
 }
 export declare const PREFIXES: {
-    readonly workflow: "wf_";
-    readonly view: "vw_";
-    readonly agent: "agt_";
+    readonly workflow: 'wf_';
+    readonly view: 'vw_';
+    readonly agent: 'agt_';
 };

package/dist/core/tree.d.ts

@@ -1,3 +1,5 @@
+import { FOLDER } from '../integrations/disk.ts';
+export { FOLDER };
 export interface Tree {
     readonly at: string;
     readonly dir: string;
@@ -5,8 +7,9 @@ export interface Tree {
     readonly root: string;
 }
 export declare class UnthreadedRepositoryError extends Error {
-    constructor(from: string);
+    constructor(from: string, floor?: string);
 }
+export declare function folder(): string;
 export declare function findTree(from?: string): Tree;
 export declare function strayFiles(root: string, prefix: string, ends: string): readonly string[];
 export declare function inTree(tree: Tree, file: string): string;

package/dist/core/tree.js

@@ -1,16 +1,34 @@
-import { existsSync, readdirSync, statSync } from "./files.js";
+import { FOLDER, attached, existsSync, readdirSync, statSync } from '../integrations/disk.js';
 import { dirname, join, relative, resolve } from 'node:path';
-import { cwd } from 'node:process';
+import { cwd, env } from 'node:process';
+export { FOLDER };
 const NAMES = ['_threads', 'threads'];
 const ROOT = 'thread.ts';
 export class UnthreadedRepositoryError extends Error {
-    constructor(from) {
-        super(`no tree above ${from} — looked for a ${NAMES.map((one) => `${one}/`).join(' or ')} directory in every directory up to the filesystem root. ` +
+    constructor(from, floor) {
+        super('no tree above ' + from + ' — looked for a ' + NAMES.map((one) => one + '/').join(' or ') + ' directory in every directory up to ' + (floor === undefined ? 'the filesystem root' : floor + ', the folder this was pointed at') + '. ' +
             'Run `thread init` to write one.');
         this.name = 'UnthreadedRepositoryError';
     }
 }
-export function findTree(from = cwd()) {
+function given() {
+    const named = env[FOLDER];
+    return named === undefined ? '' : named;
+}
+export function folder() {
+    const named = given();
+    if (named !== '')
+        return resolve(named);
+    if (attached())
+        throw new Error('this is answering for a tree on another machine and nothing said which folder that is. ' +
+            FOLDER +
+            ' carries it and is not set here. Falling back to the folder this process was started in would read ' +
+            'the wrong tree and report it as yours, so it stopped instead.');
+    return cwd();
+}
+export function findTree(from = folder()) {
+    const named = given();
+    const floor = attached() && named !== '' ? resolve(named) : undefined;
     let at = resolve(from);
     for (;;) {
         for (const name of NAMES) {
@@ -20,7 +38,9 @@ export function findTree(from = cwd()) {
         }
         const up = dirname(at);
         if (up === at)
-            throw new UnthreadedRepositoryError(from);
+            throw new UnthreadedRepositoryError(from, floor);
+        if (at === floor)
+            throw new UnthreadedRepositoryError(from, floor);
         at = up;
     }
 }

package/dist/core/tree.ts

@@ -1,6 +1,8 @@
-import { existsSync, readdirSync, statSync } from './files.ts'
+import { FOLDER, attached, existsSync, readdirSync, statSync } from '../integrations/disk.ts'
 import { dirname, join, relative, resolve } from 'node:path'
-import { cwd } from 'node:process'
+import { cwd, env } from 'node:process'
+
+export { FOLDER }
 
 const NAMES = ['_threads', 'threads'] as const
 const ROOT = 'thread.ts'
@@ -13,16 +15,36 @@ export interface Tree {
 }
 
 export class UnthreadedRepositoryError extends Error {
-  constructor(from: string) {
+  constructor(from: string, floor?: string) {
     super(
-      `no tree above ${from} — looked for a ${NAMES.map((one) => `${one}/`).join(' or ')} directory in every directory up to the filesystem root. ` +
+      'no tree above ' + from + ' — looked for a ' + NAMES.map((one) => one + '/').join(' or ') + ' directory in every directory up to ' + (floor === undefined ? 'the filesystem root' : floor + ', the folder this was pointed at') + '. ' +
         'Run `thread init` to write one.',
     )
     this.name = 'UnthreadedRepositoryError'
   }
 }
 
-export function findTree(from: string = cwd()): Tree {
+function given(): string {
+  const named = env[FOLDER]
+  return named === undefined ? '' : named
+}
+
+export function folder(): string {
+  const named = given()
+  if (named !== '') return resolve(named)
+  if (attached())
+    throw new Error(
+      'this is answering for a tree on another machine and nothing said which folder that is. ' +
+        FOLDER +
+        ' carries it and is not set here. Falling back to the folder this process was started in would read ' +
+        'the wrong tree and report it as yours, so it stopped instead.',
+    )
+  return cwd()
+}
+
+export function findTree(from: string = folder()): Tree {
+  const named = given()
+  const floor = attached() && named !== '' ? resolve(named) : undefined
   let at = resolve(from)
   for (;;) {
     for (const name of NAMES) {
@@ -30,7 +52,8 @@ export function findTree(from: string = cwd()): Tree {
       if (existsSync(dir) && statSync(dir).isDirectory()) return { at, dir, name, root: join(dir, ROOT) }
     }
     const up = dirname(at)
-    if (up === at) throw new UnthreadedRepositoryError(from)
+    if (up === at) throw new UnthreadedRepositoryError(from, floor)
+    if (at === floor) throw new UnthreadedRepositoryError(from, floor)
     at = up
   }
 }

package/dist/core/types.d.ts

@@ -1,8 +1,8 @@
-export declare const VALUE_TYPES: readonly ["text", "number", "boolean", "date", "timestamp", "json"];
+export declare const VALUE_TYPES: readonly ['text', 'number', 'boolean', 'date', 'timestamp', 'json'];
 export type ValueType = (typeof VALUE_TYPES)[number];
-export declare const KEYBOARDS: readonly ["text", "numeric", "decimal", "tel", "email", "url", "search"];
+export declare const KEYBOARDS: readonly ['text', 'numeric', 'decimal', 'tel', 'email', 'url', 'search'];
 export type Keyboard = (typeof KEYBOARDS)[number];
-export declare const ENTRY_MODES: readonly ["plain", "calculator", "masked"];
+export declare const ENTRY_MODES: readonly ['plain', 'calculator', 'masked'];
 export type EntryMode = (typeof ENTRY_MODES)[number];
 export type Checked = {
     readonly ok: true;

package/dist/core/types.js

@@ -233,7 +233,9 @@ export const FORMATS = [
         check: instant,
         requires: ['now'],
         shown: (value, facts) => {
-            const now = facts.now ?? Date.parse(new Date().toISOString());
+            const now = facts.now;
+            if (now === undefined)
+                return String(value);
             const gap = Date.parse(String(value)) - now;
             const UNITS = [
                 ['year', 31_536_000_000],

package/dist/core/types.ts

@@ -270,7 +270,8 @@ export const FORMATS: readonly Format[] = [
     check: instant,
     requires: ['now'],
     shown: (value, facts) => {
-      const now = facts.now ?? Date.parse(new Date().toISOString())
+      const now = facts.now
+      if (now === undefined) return String(value)
       const gap = Date.parse(String(value)) - now
       const UNITS: readonly (readonly [Intl.RelativeTimeFormatUnit, number])[] = [
         ['year', 31_536_000_000],

package/dist/derivation/attach.js

@@ -1,4 +1,4 @@
-import { quoted } from "../core/rows.js";
+import { quoted } from '../core/rows.js';
 const DESCRIBES = 'What turns a declaration into a file: the rows that state something is to be made, and the generators that make it. They are kept apart so you can read what an app declares without opening the machinery that builds it.';
 const DERIVATION_SOURCE = [
     "import type { Threaded } from '../core/thread.ts'",