@prestack/thread 0.1.21 → 0.1.23

package/dist/derivation/generators/build.js

@@ -12,7 +12,7 @@ import { argv, cwd, stderr, stdout } from 'node:process';
 import { pathToFileURL } from 'node:url';
 import { build, initialize, stop } from 'esbuild-wasm/esm/browser.js';
 import { descend, reached } from '../../core/descend.js';
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from '../../integrations/disk.js';
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from '../../integrations/disk.js';
 import { exit, invoked } from '../../core/invoked.js';
 import { valuesIn } from '../../core/rows.js';
 import { findTree } from '../../core/tree.js';
@@ -83,35 +83,110 @@ function exported(held, sub, conditions) {
     }
     return undefined;
 }
-function packaged(specifier, from, conditions, top) {
-    const name = specifier.split('/').slice(0, specifier.startsWith('@') ? 2 : 1).join('/');
-    const sub = `.${specifier.slice(name.length)}`;
+function named(specifier) {
+    return specifier.split('/').slice(0, specifier.startsWith('@') ? 2 : 1).join('/');
+}
+function rooted(name, from, top) {
     for (let at = from; inside(top, at); at = dirname(at)) {
         const root = join(at, 'node_modules', name);
-        const manifest = join(root, 'package.json');
-        if (filed(manifest)) {
-            const held = JSON.parse(readFileSync(manifest, 'utf8'));
-            if (held.exports !== undefined) {
-                const found = exported(held.exports, sub, conditions);
-                return found === undefined ? undefined : located(join(root, found));
-            }
-            const main = typeof held.main === 'string' ? held.main : typeof held.module === 'string' ? held.module : 'index.js';
-            return located(join(root, sub === '.' ? main : sub));
-        }
+        if (filed(join(root, 'package.json')))
+            return root;
         if (at === top)
             return undefined;
     }
     return undefined;
 }
-const folder = (outside, top) => ({
+function packaged(specifier, from, conditions, top) {
+    const name = named(specifier);
+    const sub = `.${specifier.slice(name.length)}`;
+    const root = rooted(name, from, top);
+    if (root === undefined)
+        return undefined;
+    const held = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+    if (held.exports !== undefined) {
+        const found = exported(held.exports, sub, conditions);
+        return found === undefined ? undefined : located(join(root, found));
+    }
+    const main = typeof held.main === 'string' ? held.main : typeof held.module === 'string' ? held.module : 'index.js';
+    return located(join(root, sub === '.' ? main : sub));
+}
+function binary(at) {
+    const bytes = readFileSync(at, 'latin1');
+    if (bytes.length < 4)
+        return false;
+    const byte = (i) => bytes.charCodeAt(i);
+    if (byte(0) === 0x7f && bytes.slice(1, 4) === 'ELF')
+        return true;
+    if (byte(0) === 0x4d && byte(1) === 0x5a)
+        return true;
+    if (bytes.slice(0, 4) === '\0asm')
+        return true;
+    if (byte(1) === 0xfa && byte(2) === 0xed && byte(3) === 0xfe && (byte(0) === 0xce || byte(0) === 0xcf))
+        return true;
+    if (byte(0) === 0xfe && byte(1) === 0xed && byte(2) === 0xfa && (byte(3) === 0xce || byte(3) === 0xcf))
+        return true;
+    if (byte(0) === 0xca && byte(1) === 0xfe && byte(2) === 0xba && (byte(3) === 0xbe || byte(3) === 0xbf))
+        return true;
+    return false;
+}
+function owned(root) {
+    const found = [];
+    const seen = new Set();
+    const walk = (at) => {
+        const real = realpathSync(at);
+        if (seen.has(real))
+            return;
+        seen.add(real);
+        for (const one of readdirSync(at)) {
+            if (one === 'node_modules')
+                continue;
+            const path = join(at, one);
+            const held = statSync(path, { throwIfNoEntry: false });
+            if (held?.isDirectory() === true)
+                walk(path);
+            else if (held?.isFile() === true)
+                found.push(path);
+        }
+    };
+    walk(root);
+    return found;
+}
+const staying = new Map();
+function installed(root, top, visiting = new Set()) {
+    const cached = staying.get(root);
+    if (cached !== undefined)
+        return cached;
+    if (visiting.has(root))
+        return false;
+    visiting.add(root);
+    let decided = owned(root).some(binary);
+    if (!decided) {
+        const held = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+        const names = Object.keys(held.optionalDependencies ?? {});
+        decided = names.some((one) => {
+            const found = rooted(one, root, top);
+            return found !== undefined && installed(found, top, visiting);
+        });
+    }
+    visiting.delete(root);
+    staying.set(root, decided);
+    return decided;
+}
+const folder = (outside, top, keeping) => ({
     name: 'thread-folder',
     setup(held) {
         held.onResolve({ filter: /.*/ }, (args) => {
             const bare = !args.path.startsWith('.') && !isAbsolute(args.path);
             if (args.path.startsWith('node:') || RUNTIME.has(args.path))
                 return { path: args.path, external: true, sideEffects: false };
-            if (bare && outside)
-                return { path: args.path, external: true };
+            if (bare && outside) {
+                const name = named(args.path);
+                const root = rooted(name, args.resolveDir, top);
+                if (root !== undefined && installed(root, top)) {
+                    keeping?.add(name);
+                    return { path: args.path, external: true };
+                }
+            }
             const conditions = args.kind === 'require-call' || args.kind === 'require-resolve' ? REQUIRED : IMPORTED;
             const path = resolve(args.resolveDir, args.path);
             const found = bare ? packaged(args.path, args.resolveDir, conditions, top) : inside(top, path) ? located(path) : undefined;
@@ -141,13 +216,13 @@ export async function bundle(options) {
     hosted.self ??= globalThis;
     await initialize({ wasmModule: compiled, worker: false });
     try {
-        const { packages, plugins, absWorkingDir = cwd(), ...rest } = options;
+        const { packages, plugins, keeping, absWorkingDir = cwd(), ...rest } = options;
         const made = await build({
             absWorkingDir,
             ...rest,
             bundle: true,
             write: false,
-            plugins: [...(plugins ?? []), folder(packages === 'external', absWorkingDir)],
+            plugins: [...(plugins ?? []), folder(packages === 'external', absWorkingDir, keeping)],
         });
         const text = made.outputFiles?.[0]?.text;
         if (text === undefined)
@@ -323,13 +398,15 @@ async function main() {
         }
         const forBrowser = browsing(entry);
         const refusals = forBrowser ? withheld(pass) : new Map();
+        const keeping = forBrowser ? undefined : new Set();
         let held;
         try {
             held = await bundle({
                 entryPoints: [resolve(ROOT, entry)],
                 format: 'esm',
+                minify: true,
                 platform: forBrowser ? 'browser' : 'node',
-                ...(forBrowser ? {} : { packages: 'external' }),
+                ...(keeping === undefined ? {} : { packages: 'external', keeping }),
                 outfile: at,
                 plugins: [declared(), ...(refusals.size === 0 ? [] : [withholding(refusals)]), ...compiling],
                 logLevel: 'silent',
@@ -339,16 +416,21 @@ async function main() {
             stderr.write(`build: ${out} was not written — ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
             exit(1);
         }
+        const installs = keeping === undefined
+            ? ''
+            : keeping.size === 0
+                ? ' Every package it imports is compiled in, so npm installs nothing to run it.'
+                : ` It still needs npm to install ${String(keeping.size)} package${keeping.size === 1 ? '' : 's'}: ${[...keeping].sort().join(', ')}. Each one loads a native file or starts a program that only exists once npm installs it.`;
         if (checking) {
             if (held !== before) {
                 stderr.write(`build: ${out} is not what ${BUILDS} writes. A built artifact has no author — run \`${BUILDS}\` and commit the result.\n`);
                 exit(1);
             }
-            stdout.write(`build: ${out} is up to date — ${String(new Set(reached()).size)} declared file(s) reachable.\n`);
+            stdout.write(`build: ${out} is up to date — ${String(new Set(reached()).size)} declared file(s) reachable.${installs}\n`);
             continue;
         }
         writeFileSync(at, held, 'utf8');
-        stdout.write(`build: wrote ${out} from ${entry} — ${String(new Set(reached()).size)} declared file(s) reachable.\n`);
+        stdout.write(`build: wrote ${out} from ${entry} — ${String(new Set(reached()).size)} declared file(s) reachable.${installs}\n`);
     }
 }
 if (invoked(import.meta.url))

package/dist/derivation/generators/release.js

@@ -1,15 +1,21 @@
 import { join } from 'node:path';
 import { argv, stderr, stdout } from 'node:process';
-import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.js';
+import { existsSync, readFileSync, readdirSync, writeFileSync } from '../../integrations/disk.js';
+import { COPY_AT, PROGRAM } from '../../integrations/cli.js';
+import { VAULT_DIR } from '../../integrations/vault.js';
 import { exit, invoked } from '../../core/invoked.js';
-import { marked, valuesIn } from '../../core/rows.js';
+import { markOf, valuesIn } from '../../core/rows.js';
 import { ours } from '../../core/scope.js';
 import { findTree, inTree } from '../../core/tree.js';
+import { declaresUi } from '../../integrations/declared.js';
+import { SERVER_OUT } from '../../operations/capabilities.js';
 import { CHECKED_BY, KINDS, LISTENS, SAID, WRITES, WRITTEN_BY, kindOf } from '../release.js';
 const TREE = findTree();
 const MANIFEST = 'package.json';
+const RECEIPT = join(VAULT_DIR, 'gate.json');
+const ROUTE = /^app\/(?:.+\/)?route\.ts$/;
 const addressed = (rows) => rows.flatMap((one) => [...(one.at === undefined ? [] : [one.at]), ...addressed(one.derives ?? [])]);
-const mark = (one) => marked([one.id ?? '', one.at ?? '']);
+const mark = (one) => markOf(one);
 function releases() {
     const at = inTree(TREE, 'derivation.ts');
     if (!existsSync(at))
@@ -32,35 +38,73 @@ function manager() {
         return 'npm';
     }
 }
-function scripted() {
-    const tool = manager();
-    return { build: `${tool} run build`, start: tool === 'npm' ? 'npm start' : `${tool} start` };
+function served() {
+    const found = new Set();
+    const walk = (held) => {
+        if (held === null || typeof held !== 'object')
+            return;
+        const row = held;
+        const routes = Array.isArray(row.derives) ? row.derives.filter((one) => ROUTE.test(one.at ?? '')) : [];
+        if (typeof row.at === 'string' && !row.at.startsWith(`${TREE.name}/`) && routes.length > 0)
+            found.add(row.at);
+        for (const one of Object.values(held))
+            walk(one);
+    };
+    for (const name of readdirSync(TREE.dir).filter((one) => one.endsWith('.ts')).sort()) {
+        walk(valuesIn(readFileSync(join(TREE.dir, name), 'utf8')));
+    }
+    return [...found].sort();
+}
+function runsThread() {
+    const at = inTree(TREE, 'targets.ts');
+    if (!existsSync(at))
+        return false;
+    const held = valuesIn(readFileSync(at, 'utf8'));
+    return (held.TARGETS ?? []).some((one) => one.id === PROGRAM);
 }
-function dockerfile(build, start) {
+function dockerfile() {
     const tool = manager();
     const corepack = tool === 'npm' ? [] : ['RUN corepack enable'];
     const lock = tool === 'npm' ? 'package-lock.json*' : `${tool}-lock.yaml*`;
-    const first = tool === 'npm'
-        ? 'RUN npm ci --omit=dev --ignore-scripts || npm install --omit=dev --ignore-scripts'
-        : `RUN ${tool} install --prod --frozen-lockfile --ignore-scripts || ${tool} install --prod --ignore-scripts`;
-    const all = tool === 'npm' ? 'RUN npm install --ignore-scripts' : `RUN ${tool} install --ignore-scripts`;
+    const install = tool === 'npm'
+        ? 'RUN npm ci --ignore-scripts || npm install --ignore-scripts'
+        : `RUN ${tool} install --frozen-lockfile --ignore-scripts || ${tool} install --ignore-scripts`;
+    const thread = runsThread();
+    const carried = [RECEIPT, ...served(), ...(thread ? [COPY_AT] : [])];
+    const running = ['WORKDIR /app', 'ENV NODE_ENV=production', 'ENV HOSTNAME=0.0.0.0', `ENV PORT=${String(LISTENS)}`];
+    const ending = [...(thread ? [`RUN mkdir -p ${TREE.name}`] : []), `EXPOSE ${String(LISTENS)}`];
+    if (!declaresUi(TREE)) {
+        const production = tool === 'npm'
+            ? 'RUN npm ci --omit=dev --ignore-scripts || npm install --omit=dev --ignore-scripts'
+            : `RUN ${tool} install --prod --frozen-lockfile --ignore-scripts || ${tool} install --prod --ignore-scripts`;
+        return [
+            'FROM node:22-slim',
+            ...running,
+            ...corepack,
+            `COPY package.json ${lock} ./`,
+            production,
+            ...[SERVER_OUT, ...carried].map((one) => `COPY ${one} ./${one}`),
+            ...ending,
+            `CMD ${JSON.stringify(['node', SERVER_OUT])}`,
+            '',
+        ].join('\n');
+    }
     return [
         'FROM node:22-slim AS build',
         'WORKDIR /app',
         ...corepack,
         `COPY package.json ${lock} ./`,
-        first,
+        install,
         'COPY . .',
-        all,
-        `RUN ${build}`,
+        `RUN ${tool} run build`,
         '',
         'FROM node:22-slim',
-        'WORKDIR /app',
-        ...corepack,
-        'ENV NODE_ENV=production',
-        'COPY --from=build /app ./',
-        `EXPOSE ${String(LISTENS)}`,
-        `CMD ${JSON.stringify(start.split(' '))}`,
+        ...running,
+        'COPY --from=build /app/.next/standalone ./',
+        'COPY --from=build /app/.next/static ./.next/static',
+        ...carried.map((one) => `COPY --from=build /app/${one} ./${one}`),
+        ...ending,
+        `CMD ${JSON.stringify(['node', 'server.js'])}`,
         '',
     ].join('\n');
 }
@@ -76,7 +120,10 @@ function compose(id) {
 }
 function withheld() {
     return [
-        '.thread',
+        VAULT_DIR,
+        `!${RECEIPT}`,
+        ...(runsThread() ? [`!${COPY_AT}`] : []),
+        '.next',
         'node_modules',
         '.git',
         '',
@@ -85,7 +132,6 @@ function withheld() {
 function made() {
     const found = new Map();
     const rows = releases();
-    const { build, start } = scripted();
     for (const one of rows) {
         const id = one.id;
         if (id === undefined)
@@ -94,7 +140,7 @@ function made() {
         if (kind === undefined)
             continue;
         if (kind === 'docker') {
-            found.set('Dockerfile', dockerfile(build, start));
+            found.set('Dockerfile', dockerfile());
             found.set('compose.yaml', compose(id));
             found.set('.dockerignore', withheld());
         }
@@ -187,8 +233,11 @@ function run() {
     }
     for (const [at, text] of files)
         writeFileSync(join(TREE.at, at), text, 'utf8');
-    stdout.write('release: wrote ' + [...files.keys()].join(', ') + ' — built and started by what this app\'s own manifest ' +
-        'declares, listening on ' + String(LISTENS) + '.\n' +
+    stdout.write('release: wrote ' + [...files.keys()].join(', ') + ' — ' +
+        (declaresUi(TREE)
+            ? 'built by the build this app\'s own manifest declares, and started by `node server.js` from what that build compiled'
+            : 'started by `node ' + SERVER_OUT + '`, the server `thread build` compiled into this tree, beside only the packages installed for production') +
+        ', listening on ' + String(LISTENS) + '.\n' +
         'release: no secret is named there. A secret is read from the sealed store at the moment it is used, and ' +
         'naming it here would be telling whoever deploys this to put a credential in the environment instead.\n');
     return 0;

package/dist/derivation/release.js

@@ -4,7 +4,7 @@ export const WRITES = {
     docker: [
         {
             at: 'Dockerfile',
-            describes: 'How this app becomes an image and what starts it inside one — the build and start commands its own manifest declares, run with the package manager that manifest names, and the port its server listens on.',
+            describes: 'How this app becomes an image, and what starts it inside one. An app that declares `ui` is built inside the image by the build command its own manifest declares, with the package manager that manifest names, and started with `node server.js` from what Next compiled. One that does not builds nothing there: it is started with Node on the server `thread build` compiled into this tree, beside only the packages its manifest installs for production. Either way the image keeps the files its routes read from disk, the receipt of the gate that passed, and the compiled thread command when this app runs one. Nothing of the framework\'s source goes in either way.',
         },
         {
             at: 'compose.yaml',
@@ -12,13 +12,13 @@ export const WRITES = {
         },
         {
             at: '.dockerignore',
-            describes: 'What a build of this image must never carry out of this directory: the sealed store and the key that opens it, the installed packages, and the history. Without it the build copies everything beside it, and every sealed value goes into the image and into whoever pulls it.',
+            describes: 'What a build of this image must never carry out of this directory: the sealed store and the key that opens it, an earlier build, the installed packages, and the history. From the sealed store\'s folder it lets through only the receipt of the gate that passed and, when this app runs the thread command, the compiled copy of that command. Neither holds a secret. Without it the build copies everything beside it, and every sealed value goes into the image and into whoever pulls it.',
         },
     ],
 };
 export const LISTENS = 3000;
 export const SAID = {
-    docker: 'A container image built from this app and the compose file that runs it. It is the one that needs no account and no network to be proven, so it is what an app can be taken end to end with before anybody has chosen where it really lives. What it holds is derived: the build and start commands this app already declares, the port its own server listens on, and the name of every secret it says it must be given — the names only, because a value is typed by a person and a row has never held one.',
+    docker: 'A container image built from this app and the compose file that runs it. It needs no account and no network to be proven, so an app can be taken end to end with it before anybody has chosen where it really lives. What it holds is derived: the server, on the port it listens on, with the files its routes read from disk, the receipt of the gate that passed, and the compiled thread command when this app runs one. An app that declares `ui` is served by what Next compiles, started with `node server.js`; one that does not is served by the server `thread build` compiled into this tree, started with Node beside only the packages its manifest installs for production. It names no secret, because a value is typed by a person and read from the sealed store where it is used.',
 };
 export const kindOf = (id) => KINDS.find((one) => id.startsWith(PREFIXES[one]));
 export const WRITTEN_BY = 'thread release';

package/dist/integrations/cli.d.ts

@@ -26,7 +26,6 @@ export declare const PROGRAM: string;
 export declare const COPIES: string;
 export declare const COPY_AT: string;
 export declare function running(name: string, subcommands: Readonly<Record<string, string>>, at: string): Running;
-export { calls, expansions, type Expansion } from '../integrations/declared.ts';
 export { LOCKFILES };
 export declare const manager: (into: string) => string;
 export declare function adding(into: string): readonly [string, string];

package/dist/integrations/cli.js

@@ -263,6 +263,46 @@ function forgets(one, asked) {
             one.known.delete(key);
     }
 }
+const AHEAD = 32;
+const upOf = (at) => (at.includes('/') ? at.slice(0, at.lastIndexOf('/')) : '');
+const nameOf = (at) => at.slice(at.lastIndexOf('/') + 1);
+const inside = (at, name) => (at === '' ? name : at + '/' + name);
+function listedAt(one, at) {
+    const held = one.known.get(told({ order: 'list', at }))?.found;
+    return Array.isArray(held) ? held : [];
+}
+function realOf(one, at) {
+    const held = one.known.get(told({ order: 'real', at }));
+    if (held !== undefined || at === '')
+        return held;
+    const entry = listedAt(one, upOf(at)).find((each) => each.name === nameOf(at));
+    if (entry === undefined || entry.kind === 'other')
+        return undefined;
+    const above = realOf(one, upOf(at));
+    return typeof above?.at === 'string' ? { answered: 'real', at: above.at + '/' + nameOf(at) } : undefined;
+}
+function aheadOf(one, asked) {
+    if (asked.order === 'real')
+        return asked.at === '' || one.known.has(told({ order: 'real', at: '' })) ? [] : [{ order: 'real', at: '', ahead: true }];
+    const name = nameOf(asked.at);
+    const dot = name.indexOf('.');
+    const reading = asked.order === 'read' && dot > 0 && asked.at.split('/').includes(INSTALLED);
+    if (!reading && asked.order !== 'stat')
+        return [];
+    const suffix = reading ? name.slice(dot) : '';
+    const up = upOf(asked.at);
+    const found = [];
+    for (const each of listedAt(one, up)) {
+        if (found.length === AHEAD)
+            break;
+        if (each.kind !== 'file' || each.name === name || !each.name.endsWith(suffix))
+            continue;
+        const order = { order: asked.order, at: inside(up, each.name), ahead: true };
+        if (!one.known.has(told(order)))
+            found.push(order);
+    }
+    return found;
+}
 const plainly = (one) => one.order + ' ' + (one.at === '' ? '.' : one.at);
 const outside = (root, at) => {
     const step = relative(root, at);
@@ -315,11 +355,22 @@ function watching(one) {
                 reply(one.dir, short, known);
                 continue;
             }
+            const derived = asked.order === 'real' ? realOf(one, asked.at) : undefined;
+            if (derived !== undefined) {
+                reply(one.dir, short, derived);
+                kept(one, asked, derived);
+                continue;
+            }
             if (!READS.has(asked.order))
                 forgets(one, asked);
             const due = one.replaying.shift();
             if (due !== undefined) {
                 if (told(due.order) === told(asked)) {
+                    while (one.replaying[0]?.order.ahead === true) {
+                        const extra = one.replaying.shift();
+                        if (extra !== undefined)
+                            kept(one, extra.order, extra.answered);
+                    }
                     reply(one.dir, short, due.answered);
                     kept(one, asked, due.answered);
                     continue;
@@ -334,7 +385,8 @@ function watching(one) {
             }
             one.pending = short;
             one.asking = asked;
-            hand(one, still(one, [asked]));
+            one.ahead = aheadOf(one, asked);
+            hand(one, still(one, [asked, ...one.ahead]));
         }
     }, TICK);
 }
@@ -362,11 +414,11 @@ function next(one, within) {
         }, Math.max(1_000, within - MARGIN));
     });
 }
-function begun(from, word, args, root, hears, called, recording = []) {
+function begun(from, word, args, root, hears, called, recording = [], stash) {
     const of = called ?? randomBytes(6).toString('hex');
     const dir = join(tmpdir(), SERVED, randomBytes(6).toString('hex'));
     writeFileSync(join(dir, 'channel'), '', 'utf8');
-    const one = { of, dir, root, out: '', err: '', why: '', pending: '', waiting: [], parked: [], replaying: [...recording], handed: recording.length, known: new Map() };
+    const one = { of, dir, root, out: '', err: '', why: '', pending: '', waiting: [], parked: [], replaying: [...recording], handed: recording.length, known: new Map(), ahead: [], ...(stash === undefined ? {} : { stash }) };
     const child = spawn(execPath, [...from.words, word, ...args], {
         cwd: from.own,
         shell: false,
@@ -397,6 +449,7 @@ function counted(one, held) {
     one.last = held;
     return held;
 }
+const stashing = (one, held) => (one.stash === undefined ? held : { ...held, stashed: one.stash });
 async function served(word, args, within, how) {
     const of = how?.of;
     if (of !== undefined) {
@@ -411,20 +464,26 @@ async function served(word, args, within, how) {
             const from = startable();
             if (typeof from === 'string')
                 return nowhere(from);
-            const again = begun(from, word, args, root, how?.hears, of, recording);
-            return counted(again, await next(again, within));
+            const again = begun(from, word, args, root, how?.hears, of, recording, how?.stash);
+            return stashing(again, counted(again, await next(again, within)));
         }
         const answering = how?.answering;
         if (answering !== undefined && answering < one.handed && one.last !== undefined)
-            return one.last;
-        const given = (how?.answered ?? [])[0];
+            return stashing(one, one.last);
+        const [given, ...rest] = how?.answered ?? [];
         if (one.pending !== '' && given !== undefined) {
+            one.ahead.forEach((order, index) => {
+                const held = rest[index];
+                if (held !== undefined)
+                    kept(one, order, held);
+            });
+            one.ahead = [];
             reply(one.dir, one.pending, given);
             if (one.asking !== undefined)
                 kept(one, one.asking, given);
             one.pending = '';
         }
-        return counted(one, await next(one, within));
+        return stashing(one, counted(one, await next(one, within)));
     }
     const root = how?.at ?? '';
     if (root === '')
@@ -432,8 +491,8 @@ async function served(word, args, within, how) {
     const from = startable();
     if (typeof from === 'string')
         return nowhere(from);
-    const fresh = begun(from, word, args, root, how?.hears);
-    return counted(fresh, await next(fresh, within));
+    const fresh = begun(from, word, args, root, how?.hears, undefined, [], how?.stash);
+    return stashing(fresh, counted(fresh, await next(fresh, within)));
 }
 export function running(name, subcommands, at) {
     const out = {};
@@ -451,7 +510,6 @@ export function running(name, subcommands, at) {
     }
     return out;
 }
-export { calls, expansions } from '../integrations/declared.js';
 export { LOCKFILES };
 export const manager = (into) => managerOf(into, existsSync);
 const ADDS = { pnpm: 'add', yarn: 'add', bun: 'add', npm: 'install' };

package/dist/integrations/declared.d.ts

@@ -1,4 +1,5 @@
 import { type Call, type Running, type Target } from '../integrations/target.ts';
+import { type Tree } from '../core/tree.ts';
 export interface Expansion {
     readonly program: string;
     readonly target: Target;
@@ -6,3 +7,4 @@ export interface Expansion {
 }
 export declare function expansions(at: string): readonly Expansion[];
 export declare function calls(target: string, at: string): Running;
+export declare function declaresUi(tree: Tree): boolean;

package/dist/integrations/declared.js

@@ -1,7 +1,7 @@
 import { running } from '../integrations/cli.js';
 import { existsSync, readFileSync } from '../integrations/disk.js';
 import { CALL_PREFIX, REACH } from '../integrations/target.js';
-import { valuesIn } from '../core/rows.js';
+import { holdsRow, listBounds, valuesIn } from '../core/rows.js';
 import { findTree, inTree } from '../core/tree.js';
 function sheet(at) {
     const path = inTree(findTree(at), 'targets.ts');
@@ -20,3 +20,8 @@ export function calls(target, at) {
             named[one.id.replace(CALL_PREFIX, '')] = one.path;
     return running(target.replace(REACH.cli, ''), named, at);
 }
+export function declaresUi(tree) {
+    const held = readFileSync(tree.root, 'utf8');
+    const declares = listBounds(held, 'declares');
+    return declares !== undefined && holdsRow(held, declares, 'ui');
+}

package/dist/integrations/pglite.js

@@ -52,14 +52,24 @@ export async function shapeOf(sql) {
     }
 }
 export function standing(held) {
-    const store = storing({ ...held, at: 'memory://', migrations: [] });
+    const store = storing({ ...held, at: 'memory://' });
     const keeps = Object.keys(held.tables);
     return {
         keeps,
         store,
         async seed(actor, rows) {
-            for (const one of rows)
+            for (const one of rows) {
+                const by = held.address[one.entity];
+                const key = by === undefined ? undefined : one.row[by];
+                if (by !== undefined && (typeof key === 'string' || typeof key === 'number')) {
+                    const there = await store.list(actor, one.entity, { where: { [by]: key }, limit: 1 });
+                    if (there.length > 0) {
+                        await store.update(actor, one.entity, key, one.row);
+                        continue;
+                    }
+                }
                 await store.insert(actor, one.entity, one.row);
+            }
         },
         async taken(actor) {
             const found = {};
@@ -83,7 +93,7 @@ export function storing(held) {
         const found = held.address[entity];
         if (found === undefined) {
             throw new Error(entity + ' declares nothing that identifies one of its rows, so a row of it cannot be addressed here. ' +
-                'Give it a value and say so with `thread create entity edit`.');
+                'Name the value that does: give `thread edit ' + entity + ' --must` its invariants again with one more, unique over that value alone.');
         }
         return found;
     };

package/dist/integrations/target.d.ts

@@ -68,6 +68,7 @@ export interface Order {
     readonly said?: string;
     readonly mode?: number;
     readonly words?: readonly string[];
+    readonly ahead?: boolean;
 }
 export interface Answer {
     readonly answered: string;
@@ -87,6 +88,7 @@ export interface How {
     readonly answered?: readonly Answer[];
     readonly recording?: readonly Recorded[];
     readonly answering?: number;
+    readonly stash?: unknown;
 }
 export interface Ran {
     readonly there: boolean;
@@ -99,6 +101,7 @@ export interface Ran {
     readonly of?: string;
     readonly asks?: readonly Order[];
     readonly lost?: string;
+    readonly stashed?: unknown;
 }
 export type Running<C extends string = string> = Readonly<Record<C, (args: readonly string[], shows?: boolean | 'errors' | 'tee', within?: number, how?: How) => Promise<Ran>>>;
 export type Calling<C extends string = string> = {

package/dist/integrity/attach.js

@@ -116,11 +116,7 @@ export const ATTACH = {
         { file: 'rules.ts', source: RULES_SOURCE },
         { file: 'gate.ts', source: GATE_SOURCE },
     ],
-    ignores: ['.thread/', '.next/', 'node_modules/', 'tsconfig.tsbuildinfo'],
-    scripts: {
-        build: 'next build',
-        start: 'next start',
-    },
+    ignores: ['.thread/', 'node_modules/', 'tsconfig.tsbuildinfo'],
     needs: {
         '@types/node': '^24.0.0',
         typescript: '^6.0.0',