@prestack/thread 0.1.20 → 0.1.22

package/dist/core/rows.d.ts

@@ -29,4 +29,9 @@ export declare function withTopField(text: string, field: string, value: string)
 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 const markOf: (row: object) => string;
+export declare function literalIn(text: string): unknown;
+export declare const unreadable: (held: unknown) => boolean;
+export declare function written(held: unknown, pad: string): string;
+export declare function withWritten(text: string, where: Bounds, id: string, field: string, held: unknown): string | undefined;
 export declare function showing(row: object, only?: readonly string[]): string;

package/dist/core/rows.js

@@ -432,6 +432,51 @@ const lines = (held, pad) => {
 export function marked(parts) {
     return createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 6);
 }
+export const markOf = (row) => {
+    const held = row;
+    return marked([
+        typeof held.id === 'string' ? held.id : '',
+        typeof held.at === 'string' ? held.at : '',
+        typeof held.describes === 'string' ? held.describes : '',
+        held.version === undefined ? '' : String(held.version),
+    ]);
+};
+const WHOLE = /^-?[0-9][0-9_]*(?:\.[0-9]+)?$/;
+export function literalIn(text) {
+    const said = text.trim();
+    if (WHOLE.test(said))
+        return Number(said.split('_').join(''));
+    const held = taken(`const held = ${said}`);
+    return held.length === 1 && held[0]?.[1] !== UNREAD ? held[0]?.[1] : UNREAD;
+}
+export const unreadable = (held) => held === UNREAD;
+const BARE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function inline(held) {
+    if (typeof held === 'string')
+        return quoted(held);
+    if (Array.isArray(held))
+        return `[${held.map(inline).join(', ')}]`;
+    if (held !== null && typeof held === 'object') {
+        const pairs = Object.entries(held).map(([key, one]) => `${BARE.test(key) ? key : quoted(key)}: ${inline(one)}`);
+        return pairs.length === 0 ? '{}' : `{ ${pairs.join(', ')} }`;
+    }
+    return String(held);
+}
+export function written(held, pad) {
+    if (!Array.isArray(held) || held.every((one) => typeof one !== 'object' || one === null))
+        return inline(held);
+    return ['[', ...held.map((one) => `${pad}  ${inline(one)},`), `${pad}]`].join('\n');
+}
+export function withWritten(text, where, id, field, held) {
+    const row = rowAt(text, where, id);
+    if (row === undefined)
+        return undefined;
+    const named = row.properties.find((one) => ts.isPropertyAssignment(one) && keyed(one) === field) ?? row.properties.at(-1);
+    if (named === undefined)
+        return undefined;
+    const line = text.lastIndexOf('\n', named.getStart()) + 1;
+    return fieldOn(text, row, field, written(held, /^[ \t]*/.exec(text.slice(line))?.[0] ?? ''));
+}
 export function showing(row, only = []) {
     const held = row;
     const keys = Object.keys(held);

package/dist/core/tree.d.ts

@@ -11,5 +11,6 @@ export declare class UnthreadedRepositoryError extends Error {
 }
 export declare function folder(): string;
 export declare function findTree(from?: string): Tree;
+export declare function declaresUi(tree: Tree): boolean;
 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,6 +1,7 @@
-import { FOLDER, attached, existsSync, readdirSync, statSync } from '../integrations/disk.js';
+import { FOLDER, attached, existsSync, readFileSync, readdirSync, statSync } from '../integrations/disk.js';
 import { dirname, join, relative, resolve } from 'node:path';
 import { cwd, env } from 'node:process';
+import { holdsRow, listBounds } from './rows.js';
 export { FOLDER };
 const NAMES = ['_threads', 'threads'];
 const ROOT = 'thread.ts';
@@ -44,6 +45,11 @@ export function findTree(from = folder()) {
         at = up;
     }
 }
+export function declaresUi(tree) {
+    const held = readFileSync(tree.root, 'utf8');
+    const declares = listBounds(held, 'declares');
+    return declares !== undefined && holdsRow(held, declares, 'ui');
+}
 export function strayFiles(root, prefix, ends) {
     const skip = new Set(['node_modules', '.git', '.next', 'dist', '_generated', 'coverage']);
     const found = [];

package/dist/derivation/generators/build.d.ts

@@ -1,6 +1,8 @@
 import { type BuildOptions } from 'esbuild-wasm/esm/browser.js';
 import { type Pass } from '../../core/descend.ts';
-export declare function bundle(options: BuildOptions): Promise<string>;
+export declare function bundle(options: BuildOptions & {
+    readonly keeping?: Set<string>;
+}): Promise<string>;
 declare function wanted(pass: Pass): readonly {
     entry: string;
     out: string;

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,14 @@ 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',
                 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 +415,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,20 @@
 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, findTree, inTree } from '../../core/tree.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 +37,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 +119,10 @@ function compose(id) {
 }
 function withheld() {
     return [
-        '.thread',
+        VAULT_DIR,
+        `!${RECEIPT}`,
+        ...(runsThread() ? [`!${COPY_AT}`] : []),
+        '.next',
         'node_modules',
         '.git',
         '',
@@ -85,7 +131,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 +139,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 +232,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

@@ -1,4 +1,4 @@
-import { LOCKFILES, type Call, type Ran, type Running, type Target } from '../integrations/target.ts';
+import { LOCKFILES, type Ran, type Running } from '../integrations/target.ts';
 export interface Starting {
     readonly at?: string;
     readonly shows?: boolean | 'errors' | 'tee';
@@ -19,20 +19,14 @@ export interface Held {
 }
 export declare function releases(): void;
 export declare function claims(root: string, runs: string): Held;
-export declare function programFor(name: string, at: string): string;
+export declare function programFor(name: string, at: string): readonly string[];
 export declare const SIGNING = "THREAD_RECEIPTS_KEY";
 export declare function signing(): string;
 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 interface Expansion {
-    readonly program: string;
-    readonly target: Target;
-    readonly calls: readonly Call[];
-}
-export declare function expansions(at: string): readonly Expansion[];
-export declare function calls(target: 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];