@dokebi/cli 0.4.1 → 0.4.26

package/dist/formatter-ignore.js

@@ -0,0 +1,344 @@
+// Code formatters and the migrations folder (D-0145). An applied migration must keep its bytes:
+// @dokebi/migrate tells a reformat from a code change by a token checksum, but a project
+// formatter (prettier, biome, eslint --fix with formatting rules) should not touch the folder at
+// all. `dokebi add` keeps the folder out of the formatters it can configure (a CLI-owned entry in
+// .prettierignore, or `!<folder>` in biome.json files.includes), and `dokebi check` warns about a
+// formatter whose config would still format it (rule formatter-migrations).
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CONFIG_FILE, parseProjectConfig } from './configuration.js';
+import { debug, describeError, isMissing } from './diagnostics.js';
+import { CliError } from './errors.js';
+/** @dokebi/migrate's `directory` default; migrations live in `<directory>/migrations/`. */
+const MIGRATE_DIRECTORY = 'src/infra/db';
+export const PRETTIER_IGNORE = '.prettierignore';
+/** The comment line above the CLI-owned .prettierignore entry. */
+export const PRETTIER_MARKER = '# dokebi: applied migrations are never reformatted (D-0145; @dokebi/migrate checks them)';
+/** The CLI-written registration; the CLI refuses a project whose copy differs (MODIFIED_REGISTRATION). */
+export const GENERATED_FILE = 'src/dokebi.generated.ts';
+/** The comment line above the CLI-owned .prettierignore entry of the generated registration. */
+export const PRETTIER_GENERATED_MARKER = '# dokebi: the CLI writes src/dokebi.generated.ts and refuses a reformatted copy (MODIFIED_REGISTRATION)';
+/** Whether a path is a migrations folder (bare `migrations` patterns keep any of those out). */
+const isMigrations = (path) => path === 'migrations' || path.endsWith('/migrations');
+const PRETTIER_CONFIGS = [
+    '.prettierrc',
+    '.prettierrc.json',
+    '.prettierrc.json5',
+    '.prettierrc.yaml',
+    '.prettierrc.yml',
+    '.prettierrc.toml',
+    '.prettierrc.js',
+    '.prettierrc.cjs',
+    '.prettierrc.mjs',
+    '.prettierrc.ts',
+    '.prettierrc.cts',
+    '.prettierrc.mts',
+    'prettier.config.js',
+    'prettier.config.cjs',
+    'prettier.config.mjs',
+    'prettier.config.ts',
+    'prettier.config.cts',
+    'prettier.config.mts',
+];
+const BIOME_CONFIGS = ['biome.json', 'biome.jsonc'];
+const ESLINT_CONFIGS = [
+    'eslint.config.js',
+    'eslint.config.mjs',
+    'eslint.config.cjs',
+    'eslint.config.ts',
+    'eslint.config.mts',
+    'eslint.config.cts',
+    '.eslintrc',
+    '.eslintrc.json',
+    '.eslintrc.js',
+    '.eslintrc.cjs',
+    '.eslintrc.yaml',
+    '.eslintrc.yml',
+];
+/** ESLint formats only through formatting rules: eslint-plugin-prettier or @stylistic. */
+const ESLINT_FORMATS = /prettier|@stylistic/;
+async function readText(root, path) {
+    try {
+        return await readFile(join(root, path), 'utf8');
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw new CliError('READ_FAILED', `Cannot read ${path}`, { cause: error });
+    }
+}
+/** The migrations folder of the project: `options.dokebi-migrate.directory` + `/migrations`. */
+export async function migrationsFolder(root) {
+    const source = await readText(root, CONFIG_FILE);
+    let directory = MIGRATE_DIRECTORY;
+    if (source !== undefined) {
+        let options = {};
+        try {
+            options = parseProjectConfig(source).options;
+        }
+        catch (error) {
+            // doctor reports an invalid dokebi.yaml; the folder falls back to the default here.
+            debug('migrations folder: dokebi.yaml not readable, default used', {
+                error: describeError(error),
+            });
+        }
+        const migrate = options['dokebi-migrate'];
+        if (typeof migrate?.directory === 'string' && migrate.directory !== '')
+            directory = migrate.directory;
+    }
+    return `${directory.replace(/^\.\//, '').replace(/\/+$/, '')}/migrations`;
+}
+/** A gitignore-style pattern without a leading `/` or a trailing `/`, `/**` or `/*`. */
+function plainPattern(line) {
+    return line
+        .trim()
+        .replace(/^\//, '')
+        .replace(/\/\*\*?$/, '')
+        .replace(/\/$/, '');
+}
+/** Whether a .prettierignore (gitignore syntax) keeps `folder` out. */
+export function prettierCovers(ignore, folder) {
+    // gitignore: the last matching line wins, so a later `!src/infra/db/migrations/` brings the
+    // folder back (it used to count as covered because a line before it ignored it).
+    let covered = false;
+    for (const raw of ignore.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line === '' || line.startsWith('#'))
+            continue;
+        const negated = line.startsWith('!');
+        const pattern = plainPattern(negated ? line.slice(1) : line);
+        if (pattern === folder ||
+            folder.startsWith(`${pattern}/`) ||
+            (isMigrations(folder) && (pattern === 'migrations' || pattern === '**/migrations')))
+            covered = !negated;
+    }
+    return covered;
+}
+/** .prettierignore with the CLI-owned entry for `folder` (unchanged when it is covered). */
+export function prettierIgnoreText(ignore, folder) {
+    if (prettierCovers(ignore, folder))
+        return ignore;
+    const end = ignore === '' || ignore.endsWith('\n') ? '' : '\n';
+    const file = folder === GENERATED_FILE;
+    return `${ignore}${end}${ignore === '' ? '' : '\n'}${file ? PRETTIER_GENERATED_MARKER : PRETTIER_MARKER}\n${folder}${file ? '' : '/'}\n`;
+}
+/** A negated biome pattern that keeps `folder` out (`!src/infra/db/migrations`, or any migrations folder). */
+function biomeExcludes(pattern, folder) {
+    if (typeof pattern !== 'string' || !pattern.startsWith('!'))
+        return false;
+    const plain = plainPattern(pattern.replace(/^!+/, ''));
+    return (plain === folder ||
+        folder.startsWith(`${plain}/`) ||
+        (isMigrations(folder) && plain === '**/migrations'));
+}
+/** Whether a parsed biome config keeps `folder` out (v2 `files.includes`, v1 `files.ignore`). */
+export function biomeCovers(config, folder) {
+    const files = config?.files;
+    if (Array.isArray(files?.includes) && files.includes.some((item) => biomeExcludes(item, folder)))
+        return true;
+    return (Array.isArray(files?.ignore) &&
+        files.ignore.some((item) => {
+            if (typeof item !== 'string')
+                return false;
+            const plain = plainPattern(item);
+            return (plain === folder ||
+                folder.startsWith(`${plain}/`) ||
+                (isMigrations(folder) && plain === '**/migrations'));
+        }));
+}
+function spans(text) {
+    const found = new Map();
+    let i = 0;
+    const space = () => {
+        while (i < text.length && /\s/.test(text[i]))
+            i++;
+    };
+    const string = () => {
+        const start = i;
+        i++;
+        while (i < text.length && text[i] !== '"')
+            i += text[i] === '\\' ? 2 : 1;
+        i++;
+        return JSON.parse(text.slice(start, i));
+    };
+    const value = (path) => {
+        space();
+        const start = i;
+        const char = text[i];
+        if (char === '{') {
+            i++;
+            space();
+            while (text[i] !== '}') {
+                space();
+                const key = string();
+                space();
+                i++; // :
+                value(path ? `${path}.${key}` : key);
+                space();
+                if (text[i] === ',')
+                    i++;
+                space();
+            }
+            i++;
+        }
+        else if (char === '[') {
+            i++;
+            space();
+            let index = 0;
+            while (text[i] !== ']') {
+                value(`${path}[${index++}]`);
+                space();
+                if (text[i] === ',')
+                    i++;
+                space();
+            }
+            i++;
+        }
+        else if (char === '"')
+            string();
+        else
+            while (i < text.length && !/[\s,}\]]/.test(text[i]))
+                i++;
+        found.set(path, { start, end: i });
+    };
+    value('');
+    return found;
+}
+/** The indentation of the first indented line (biome's default is a tab). */
+function indentOf(text) {
+    return /\n([ \t]+)\S/.exec(text)?.[1] ?? '\t';
+}
+/**
+ * biome.json with `folder` kept out, edited in place so the file stays as biome formats it:
+ * `!<folder>` appended to `files.includes` (v2), or `<folder>` to `files.ignore` (v1, `v1`), or
+ * a new `"files": { "includes": ["**", "!<folder>"] }` first in the object. Undefined when the
+ * text is not plain JSON (biome.jsonc, comments): the caller warns instead.
+ */
+export function biomeConfigText(text, folder, v1 = false) {
+    let config;
+    try {
+        config = JSON.parse(text);
+    }
+    catch (error) {
+        debug('biome config is not plain JSON; not edited', { error: describeError(error) });
+        return undefined;
+    }
+    if (config === null || typeof config !== 'object' || Array.isArray(config))
+        return undefined;
+    if (biomeCovers(config, folder))
+        return text;
+    const files = config.files;
+    const key = Array.isArray(files?.ignore) || (v1 && !Array.isArray(files?.includes)) ? 'ignore' : 'includes';
+    const entry = JSON.stringify(key === 'ignore' ? folder : `!${folder}`);
+    const map = spans(text);
+    const list = map.get(`files.${key}`);
+    if (list) {
+        const body = text.slice(list.start + 1, list.end - 1);
+        const close = list.end - 1;
+        if (body.includes('\n')) {
+            // A list over several lines: a new last line with the indentation of the others.
+            const last = text.lastIndexOf('\n', close);
+            const itemIndent = /\n([ \t]*)\S/.exec(body)?.[1] ?? indentOf(text);
+            const before = text.slice(0, last).replace(/\s*$/, '');
+            return `${before},\n${itemIndent}${entry}${text.slice(last)}`;
+        }
+        const inner = body.trim();
+        return `${text.slice(0, list.start + 1)}${inner === '' ? entry : `${inner}, ${entry}`}${text.slice(close)}`;
+    }
+    const indent = indentOf(text);
+    const filesSpan = map.get('files');
+    if (filesSpan && files && typeof files === 'object') {
+        const open = filesSpan.start + 1;
+        const multiLine = text.slice(filesSpan.start, filesSpan.end).includes('\n');
+        const value = key === 'ignore' ? `[${entry}]` : `["**", ${entry}]`;
+        const empty = Object.keys(files).length === 0;
+        return multiLine
+            ? `${text.slice(0, open)}\n${indent}${indent}"${key}": ${value}${empty ? '' : ','}${text.slice(open)}`
+            : `${text.slice(0, open)} "${key}": ${value}${empty ? ' ' : ','}${text.slice(open)}`;
+    }
+    const open = text.indexOf('{') + 1;
+    const value = key === 'ignore' ? `{ "ignore": [${entry}] }` : `{ "includes": ["**", ${entry}] }`;
+    const empty = Object.keys(config).length === 0;
+    return `${text.slice(0, open)}\n${indent}"files": ${value}${empty ? '\n' : ','}${text.slice(open)}`;
+}
+/** The major version of @biomejs/biome the project asks for, when package.json names one. */
+export function biomeMajor(pkg) {
+    for (const section of ['devDependencies', 'dependencies']) {
+        const range = pkg[section]?.['@biomejs/biome'];
+        const major = typeof range === 'string' ? /(\d+)\./.exec(range)?.[1] : undefined;
+        if (major !== undefined)
+            return Number(major);
+    }
+    return undefined;
+}
+/** The formatters the project configures and whether each leaves `folder` alone. */
+export async function formatterUses(root, folder) {
+    const uses = [];
+    const pkgText = await readText(root, 'package.json');
+    let pkg = {};
+    if (pkgText !== undefined)
+        try {
+            pkg = JSON.parse(pkgText);
+        }
+        catch (error) {
+            throw new CliError('INVALID_PACKAGE', 'package.json is not valid JSON', { cause: error });
+        }
+    const dependsOn = (name) => ['dependencies', 'devDependencies'].some((section) => pkg[section]?.[name] !== undefined);
+    let prettier;
+    for (const file of PRETTIER_CONFIGS)
+        if ((await readText(root, file)) !== undefined) {
+            prettier = file;
+            break;
+        }
+    if (prettier === undefined && (pkg.prettier !== undefined || dependsOn('prettier')))
+        prettier = 'package.json';
+    if (prettier !== undefined)
+        uses.push({
+            tool: 'prettier',
+            config: prettier,
+            covered: prettierCovers((await readText(root, PRETTIER_IGNORE)) ?? '', folder),
+        });
+    for (const file of BIOME_CONFIGS) {
+        const text = await readText(root, file);
+        if (text === undefined)
+            continue;
+        let config;
+        try {
+            config = JSON.parse(text);
+        }
+        catch (error) {
+            // biome.jsonc or comments: read as not covered unless the folder is named as excluded.
+            debug('biome config read as text', { file, error: describeError(error) });
+            config = text.includes(`!${folder}`) ? { files: { includes: [`!${folder}`] } } : {};
+        }
+        uses.push({ tool: 'biome', config: file, covered: biomeCovers(config, folder) });
+        break;
+    }
+    for (const file of ESLINT_CONFIGS) {
+        const text = await readText(root, file);
+        if (text === undefined)
+            continue;
+        if (ESLINT_FORMATS.test(text))
+            uses.push({
+                tool: 'eslint',
+                config: file,
+                covered: text.includes(folder) || (isMigrations(folder) && /['"`]\*\*\/migrations/.test(text)),
+            });
+        break;
+    }
+    return uses;
+}
+/** The one-line fix for a formatter that would format the migrations folder. */
+export function formatterFix(use, folder) {
+    const file = folder === GENERATED_FILE;
+    switch (use.tool) {
+        case 'prettier':
+            return `add ${folder}${file ? '' : '/'} to ${PRETTIER_IGNORE} (npx dokebi add writes it when it installs a plugin)`;
+        case 'biome':
+            return `add "!${folder}" to files.includes of ${use.config} (biome 1: "${folder}" to files.ignore)`;
+        case 'eslint':
+            return file
+                ? `add "${folder}" to the ignores of ${use.config}: its formatting rules would rewrite the registration the CLI writes`
+                : `add "${folder}/**" to the ignores of ${use.config}: its formatting rules would rewrite applied migrations`;
+    }
+}

package/dist/generator.d.ts

@@ -12,13 +12,47 @@ import type { Installation } from './project-state.js';
  *
  * The CLI-managed units reach the plugin whose manifest declares their role (D-0070
  * `dokebi.hosts`): `apps` (`dokebi app add`, src/apps/<name>/app.ts) and `modules`
- * (`dokebi module add`, src/shared/modules/<name>/module.ts).
+ * (`dokebi module add`, src/shared/modules/<name>/module.ts). The `logger` host (D-0151) gives
+ * the exported `createLogger` (src/main.ts passes its logger to the Application, so it writes
+ * from the first setup record), receives that logger as `entry.logger` and its options from
+ * `options.logging`; without one, `createLogger` returns undefined (core's console logger).
  */
-export declare function generateRegistration(plugins: PluginManifest[], installations?: Readonly<Record<string, Installation>>, apps?: readonly string[], modules?: readonly string[]): string;
+export declare function generateRegistration(plugins: PluginManifest[], installations?: Readonly<Record<string, Installation>>, apps?: readonly string[], modules?: readonly string[], settings?: readonly string[]): string;
 export declare const LEGACY_MAIN_SOURCE = "import { Application } from '@dokebi/core';\nimport { registerPlugins } from './dokebi.generated.ts';\n\nconst app = new Application();\nregisterPlugins(app);\nawait app.start();\ntry {\n  app.logger.log('info', 'Dokebi application started');\n  // Run local work here. Long-running apps own their signal and shutdown policy.\n} finally {\n  await app.stop();\n}\n";
 /** The 0.2.0 YAML entry point before it became long-running; migrate still recognizes it. */
 export declare const MAIN_SOURCE_V1 = "import { Application, loadConfig } from '@dokebi/core';\nimport { registerPlugins } from './dokebi.generated.ts';\n\nconst document = await loadConfig(new URL('../dokebi.yaml', import.meta.url));\nconst app = new Application({ config: document.options });\nawait registerPlugins(app);\nawait app.start();\ntry {\n  app.logger.log('info', 'Dokebi application started');\n  // Run local work here. Long-running apps own their signal and shutdown policy.\n} finally {\n  await app.stop();\n}\n";
-export declare const MAIN_SOURCE = "import { Application, loadConfig } from '@dokebi/core';\nimport { registerPlugins } from './dokebi.generated.ts';\n\nconst document = await loadConfig(new URL('../dokebi.yaml', import.meta.url));\nconst app = new Application({ config: document.options });\nawait registerPlugins(app);\nawait app.start();\napp.logger.log('info', 'Dokebi application started');\n\n// The app runs until SIGINT/SIGTERM (servers, consumers) or until nothing is left to run\n// (one-off work), then drains and cleans up once. A second Ctrl+C exits immediately.\nlet stopping: Promise<void> | undefined;\nconst stop = (reason: string) =>\n  (stopping ??= app.stop().then(\n    () => app.logger.log('info', 'Dokebi application stopped', { reason }),\n    () => {\n      process.exitCode = 1;\n      app.logger.log('error', 'Dokebi application did not stop cleanly', { reason });\n    },\n  ));\nprocess.once('SIGINT', () => void stop('SIGINT'));\nprocess.once('SIGTERM', () => void stop('SIGTERM'));\nprocess.once('beforeExit', () => void stop('idle'));\n";
+/**
+ * The long-running entry point before D-0151 (core's console logger only). `add` of a logger
+ * plugin rewrites an unchanged copy to MAIN_SOURCE; migrate still recognizes it.
+ */
+export declare const MAIN_SOURCE_V2 = "import { resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { Application, loadConfig } from '@dokebi/core';\nimport { registerPlugins } from './dokebi.generated.ts';\n\nconst configPath = resolve(process.env.DOKEBI_CONFIG ?? fileURLToPath(new URL('../dokebi.yaml', import.meta.url)));\nprocess.env.DOKEBI_CONFIG = configPath;\nconst document = await loadConfig(configPath);\nconst app = new Application({ config: document.options });\nawait registerPlugins(app);\napp.logger.log('info', 'Dokebi application started');\n\n// The app runs until SIGINT/SIGTERM (servers, consumers) or until nothing is left to run\n// (one-off work), then drains and cleans up once. A second Ctrl+C exits immediately.\nlet stopping: Promise<void> | undefined;\nconst stop = (reason: string) =>\n  (stopping ??= app.stop().then(\n    () => app.logger.log('info', 'Dokebi application stopped', { reason }),\n    () => {\n      process.exitCode = 1;\n      app.logger.log('error', 'Dokebi application did not stop cleanly', { reason });\n    },\n  ));\nprocess.once('SIGINT', () => void stop('SIGINT'));\nprocess.once('SIGTERM', () => void stop('SIGTERM'));\nprocess.once('beforeExit', () => void stop('idle'));\n";
+/**
+ * The entry point of D-0151 before D-0154 (no configFile: the app could not read dokebi.yaml
+ * again). `add` of a logger plugin rewrites an unchanged copy to MAIN_SOURCE; migrate still
+ * recognizes it.
+ */
+export declare const MAIN_SOURCE_V3 = "import { resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { Application, loadConfig } from '@dokebi/core';\nimport { createLogger, registerPlugins } from './dokebi.generated.ts';\n\nconst configPath = resolve(process.env.DOKEBI_CONFIG ?? fileURLToPath(new URL('../dokebi.yaml', import.meta.url)));\nprocess.env.DOKEBI_CONFIG = configPath;\nconst document = await loadConfig(configPath);\n// The app logger: @dokebi/logger (options.logging targets) when installed, else core's console logger.\nconst app = new Application({ config: document.options, logger: createLogger(document.options) });\nawait registerPlugins(app);\nawait app.start();\napp.logger.log('info', 'Dokebi application started');\n\n// The app runs until SIGINT/SIGTERM (servers, consumers) or until nothing is left to run\n// (one-off work), then drains and cleans up once. A second Ctrl+C exits immediately.\nlet stopping: Promise<void> | undefined;\nconst stop = (reason: string) =>\n  (stopping ??= app.stop().then(\n    () => app.logger.log('info', 'Dokebi application stopped', { reason }),\n    () => {\n      process.exitCode = 1;\n      app.logger.log('error', 'Dokebi application did not stop cleanly', { reason });\n    },\n  ));\nprocess.once('SIGINT', () => void stop('SIGINT'));\nprocess.once('SIGTERM', () => void stop('SIGTERM'));\nprocess.once('beforeExit', () => void stop('idle'));\n";
+/**
+ * The entry point of D-0154 before the IPC start message (AI-M43): `start` knew the app was up
+ * only from the info line, which logging.level warn hides. migrate still recognizes it.
+ */
+export declare const MAIN_SOURCE_V4 = "import { resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { Application, loadConfig } from '@dokebi/core';\nimport { createLogger, registerPlugins } from './dokebi.generated.ts';\n\nconst configPath = resolve(process.env.DOKEBI_CONFIG ?? fileURLToPath(new URL('../dokebi.yaml', import.meta.url)));\nprocess.env.DOKEBI_CONFIG = configPath;\nconst document = await loadConfig(configPath);\n// The app logger: @dokebi/logger (options.logging targets) when installed, else core's console logger.\n// configFile: the app reads dokebi.yaml again when it changes (options marked reloadable apply live).\nconst app = new Application({\n  config: document.options,\n  configFile: configPath,\n  logger: createLogger(document.options),\n});\nawait registerPlugins(app);\nawait app.start();\napp.logger.log('info', 'Dokebi application started');\n\n// The app runs until SIGINT/SIGTERM (servers, consumers) or until nothing is left to run\n// (one-off work), then drains and cleans up once. A second Ctrl+C exits immediately.\nlet stopping: Promise<void> | undefined;\nconst stop = (reason: string) =>\n  (stopping ??= app.stop().then(\n    () => app.logger.log('info', 'Dokebi application stopped', { reason }),\n    () => {\n      process.exitCode = 1;\n      app.logger.log('error', 'Dokebi application did not stop cleanly', { reason });\n    },\n  ));\nprocess.once('SIGINT', () => void stop('SIGINT'));\nprocess.once('SIGTERM', () => void stop('SIGTERM'));\nprocess.once('beforeExit', () => void stop('idle'));\n";
+/**
+ * The entry point of the IPC start message before an empty DOKEBI_CONFIG counted as unset
+ * (R4CB-1: `DOKEBI_CONFIG= node src/main.ts` resolved '' to the working folder and failed with
+ * CONFIG_READ_FAILED, while every CLI command reads dokebi.yaml then, D-0154 D4). migrate still
+ * recognizes it; doctor names a main.ts with this line (TEMPLATE_FIX_MISSING, template-fixes.ts).
+ */
+export declare const MAIN_SOURCE_V5 = "import { resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { Application, loadConfig } from '@dokebi/core';\nimport { createLogger, registerPlugins } from './dokebi.generated.ts';\n\nconst configPath = resolve(process.env.DOKEBI_CONFIG ?? fileURLToPath(new URL('../dokebi.yaml', import.meta.url)));\nprocess.env.DOKEBI_CONFIG = configPath;\nconst document = await loadConfig(configPath);\n// The app logger: @dokebi/logger (options.logging targets) when installed, else core's console logger.\n// configFile: the app reads dokebi.yaml again when it changes (options marked reloadable apply live).\nconst app = new Application({\n  config: document.options,\n  configFile: configPath,\n  logger: createLogger(document.options),\n});\nawait registerPlugins(app);\nawait app.start();\napp.logger.log('info', 'Dokebi application started');\n// dokebi start and verify learn that the app is up from this message as well, so a\n// logging.level above info (which hides the line above) does not look like a failed start.\nif (process.send) {\n  process.send({ dokebi: 'started' });\n  process.channel?.unref();\n}\n\n// The app runs until SIGINT/SIGTERM (servers, consumers) or until nothing is left to run\n// (one-off work), then drains and cleans up once. A second Ctrl+C exits immediately.\nlet stopping: Promise<void> | undefined;\nconst stop = (reason: string) =>\n  (stopping ??= app.stop().then(\n    () => app.logger.log('info', 'Dokebi application stopped', { reason }),\n    () => {\n      process.exitCode = 1;\n      app.logger.log('error', 'Dokebi application did not stop cleanly', { reason });\n    },\n  ));\nprocess.once('SIGINT', () => void stop('SIGINT'));\nprocess.once('SIGTERM', () => void stop('SIGTERM'));\nprocess.once('beforeExit', () => void stop('idle'));\n";
+/**
+ * src/main.ts of a new project. D-0151: the logger comes from the generated registration
+ * (@dokebi/logger when installed, else undefined: core's console logger), so it is in place
+ * before the first plugin logs. D-0154: configFile lets the app read dokebi.yaml again while it
+ * runs (a change of the file, SIGHUP, npx dokebi reload); options marked reloadable apply
+ * without a restart. An empty DOKEBI_CONFIG means dokebi.yaml, as for every CLI command (D-0154
+ * D4; `??` took '' for a path and read the working folder).
+ */
+export declare const MAIN_SOURCE: string;
 /**
  * tsconfig.json written by init. `node src/main.ts` strips types without compiling, so the
  * editor and `tsc` should reject syntax Node cannot run (erasableSyntaxOnly) and need explicit
@@ -33,4 +67,12 @@ export declare const MAIN_SOURCE = "import { Application, loadConfig } from '@do
 export declare const PROJECT_DEV_DEPENDENCIES: Readonly<Record<string, string>>;
 /** `npm run typecheck`: the checks of the generated tsconfig.json (it already sets noEmit). */
 export declare const TYPECHECK_SCRIPT = "tsc -p tsconfig.json --noEmit";
+/**
+ * `npm test` (D-0077 H): node:test over the project's `*.test.ts` files under tests (Node strips
+ * their types; none exist at first, which passes). `dokebi verify` runs it with a result per
+ * test. The pattern is quoted so node expands it the same way on every shell. It covers the
+ * maintained test folders tests/unit and tests/integration; helpers in tests/support are not
+ * named *.test.ts (D-0092 §3, the "Files and folders" rule of capability-guide.ts).
+ */
+export declare const TEST_SCRIPT = "node --test \"tests/**/*.test.ts\"";
 export declare const TSCONFIG_SOURCE: string;