@design.estate/wcctools 6.0.0 → 6.2.0

package/dist_ts/classes.devserver.js

@@ -13,81 +13,155 @@ const securityHeaders = {
 };
 const acceptAnyHostname = () => true;
 /**
- * `wcctools dev`: bundles the catalog of the current project with tswatch, as its
- * `@git.zone/tswatch` configuration (or the `element` preset) describes, and serves on one port:
+ * `wcctools dev`: bundles the catalog of a project with tswatch, as its `@git.zone/tswatch`
+ * configuration (or the `element` preset) describes, and serves on one port:
  *
  * - the shell on `/wcctools/` (`/` redirects there) and its routes `/wcctools-route/...`,
- * - the typed API on `/wcctools/typedrequest`,
+ * - the typed API on `/wcctools/typedrequest`, including the bundles' status,
  * - the catalog's preview document and bundle from the tswatch serve directory on every other
  *   path, with live reload that reloads only the preview document.
  *
- * tswatch resolves its paths against the process's working directory, so the server serves the
- * project the process runs in.
+ * The server owns no process lifecycle: while it runs, a process shutdown through smartexit's
+ * `ProcessLifecycle` stops it. The entry point installs that lifecycle with
+ * `getShutdownTimeoutMs()`.
  */
 export class WccDevServer {
     options;
     /** The typed API on `/wcctools/typedrequest`; register further handlers before `start()`. */
     api = new WccDevApi();
-    tsWatch = null;
+    /** The project directory everything resolves against. */
+    cwd;
+    /** The project's tswatch configuration, or the `element` preset; read once, on construction. */
+    config;
+    /** Bundling and watching stay tswatch's; its own server stays off. */
+    tsWatch;
     typedServer = null;
-    smartExit = new plugins.smartexit.SmartExit({ silent: true });
+    /** Stops the server on a process shutdown; registered by start(), released by stop(). */
+    smartExit = null;
+    unsubscribeBundleEvents = null;
+    running = false;
+    starting = null;
+    stopping = null;
     constructor(options = {}) {
         this.options = options;
-        this.smartExit.addCleanupFunction(() => this.stop());
+        this.cwd = plugins.path.resolve(options.cwd ?? process.cwd());
+        const configHandler = new plugins.tswatch.ConfigHandler(this.cwd);
+        this.config = configHandler.loadConfig() ?? this.getElementPreset(configHandler);
+        this.tsWatch = new plugins.tswatch.TsWatch({ ...this.config, server: { enabled: false } }, { cwd: this.cwd });
     }
+    /**
+     * The shutdown deadline the server needs, tswatch's: the entry point installs smartexit's
+     * `ProcessLifecycle` with it, so every watcher command keeps its full grace period.
+     */
+    getShutdownTimeoutMs() {
+        return this.tsWatch.getShutdownTimeoutMs();
+    }
+    /**
+     * Bundles the catalog, starts the watchers and serves. Refused while the server runs or stops;
+     * the server starts again after stop().
+     */
     async start() {
-        if (this.typedServer) {
-            throw new Error('wcctools: the dev server is already started.');
+        if (this.running || this.stopping) {
+            throw new Error('wcctools: the dev server is already started or still stopping.');
         }
-        const cwd = process.cwd();
-        const configHandler = new plugins.tswatch.ConfigHandler(cwd);
-        const config = configHandler.loadConfig() ?? configHandler.getPreset('element');
-        const serveDir = plugins.path.resolve(cwd, config.server?.serveDir ?? defaultServeDir);
-        const port = this.options.port ?? config.server?.port ?? defaultPort;
-        // The preview surface watches the serve directory, which must exist before the first bundle
-        await plugins.fs.mkdir(serveDir, { recursive: true });
-        this.api.setServerInfo({
-            wcctoolsVersion: commitinfo.version,
-            projectName: await this.readProjectName(cwd),
-        });
-        const typedServer = new plugins.typedserver.TypedServer({
-            cors: false,
-            port,
-            surfaces: [
-                await this.createShellSurface(),
-                this.createPreviewSurface(serveDir),
-            ],
-        });
-        this.typedServer = typedServer;
-        // Bundling and watching stay tswatch's; its own server stays off
-        this.tsWatch = new plugins.tswatch.TsWatch({ ...config, server: { enabled: false } });
+        this.running = true;
+        // A process shutdown stops the server from here on, also while it is still starting
+        const smartExit = new plugins.smartexit.SmartExit({ silent: true });
+        smartExit.addCleanupFunction(() => this.stop());
+        this.smartExit = smartExit;
+        const starting = this.startServing();
+        this.starting = starting;
         try {
-            await this.tsWatch.start();
-            await typedServer.start();
+            const address = await starting;
+            if (this.stopping) {
+                throw new Error('wcctools: the dev server was stopped while starting.');
+            }
+            return address;
         }
         catch (error) {
+            // A start that failed halfway releases what it opened
             await this.stop();
             throw error;
         }
-        const boundPort = typedServer.listeningPort ?? port;
-        return { port: boundPort, url: `http://localhost:${boundPort}${shellPathPrefix}/` };
+        finally {
+            if (this.starting === starting) {
+                this.starting = null;
+            }
+        }
     }
-    /** Stops the server, then tswatch's bundling and watching. */
-    async stop() {
+    /**
+     * Stops the server and tswatch's bundling and watching, and releases everything start()
+     * registered. A stop during start() waits for the start to settle first; concurrent and
+     * repeated calls share one stop.
+     */
+    stop() {
+        this.stopping ??= this.release().finally(() => {
+            this.stopping = null;
+        });
+        return this.stopping;
+    }
+    async release() {
+        await this.starting?.catch(() => undefined);
+        const smartExit = this.smartExit;
         const typedServer = this.typedServer;
-        const tsWatch = this.tsWatch;
+        const unsubscribeBundleEvents = this.unsubscribeBundleEvents;
+        this.smartExit = null;
         this.typedServer = null;
-        this.tsWatch = null;
-        this.smartExit.deregister();
-        await typedServer?.stop();
-        await tsWatch?.stop();
+        this.unsubscribeBundleEvents = null;
+        smartExit?.deregister();
+        // Status requests waiting for a change are refused now, so none holds the server's stop, and
+        // requests until the server stops listening are refused too: the shell backs off
+        this.api.bundleStatus.close();
+        try {
+            await typedServer?.stop();
+        }
+        finally {
+            try {
+                await this.tsWatch.stop();
+            }
+            finally {
+                unsubscribeBundleEvents?.();
+                this.running = false;
+            }
+        }
+    }
+    async startServing() {
+        const serveDir = plugins.path.resolve(this.cwd, this.config.server?.serveDir ?? defaultServeDir);
+        const port = this.options.port ?? this.config.server?.port ?? defaultPort;
+        // The preview surface watches the serve directory, which must exist before the first bundle
+        await plugins.fs.mkdir(serveDir, { recursive: true });
+        this.api.setServerInfo({
+            wcctoolsVersion: commitinfo.version,
+            projectName: await this.readProjectName(),
+        });
+        const surfaces = [await this.createShellSurface(), this.createPreviewSurface(serveDir)];
+        const typedServer = new plugins.typedserver.TypedServer({ cors: false, port, surfaces });
+        this.typedServer = typedServer;
+        this.api.bundleStatus.open();
+        const bundleStatus = this.api.bundleStatus;
+        this.unsubscribeBundleEvents = this.tsWatch.onBundleEvent((eventArg) => bundleStatus.record(eventArg));
+        // The initial bundles run here; a failed one is reported in the bundle status
+        await this.tsWatch.start();
+        await typedServer.start();
+        const boundPort = typedServer.listeningPort ?? port;
+        return { port: boundPort, url: `http://localhost:${boundPort}${shellPathPrefix}/` };
+    }
+    getElementPreset(configHandlerArg) {
+        const preset = configHandlerArg.getPreset('element');
+        if (!preset) {
+            throw new Error('wcctools: tswatch provides no `element` preset.');
+        }
+        return preset;
     }
     /**
      * The shell: the prebuilt shell bundle and the typed API.
      *
      * Seam for side-effecting APIs (assistant, capture, standards fixes): before any handler with
-     * side effects is registered here, add a `websocketAdmission`/`requestAdmission` that accepts
-     * only the shell's own origin, and keep surface mode's strict authority validation.
+     * side effects is registered here, the server binds to localhost by default (another interface
+     * only on explicit request), validates the Host header against the addresses it serves instead
+     * of accepting any hostname, and admits typedsocket connections and typed requests only from the
+     * shell's own origin (a `websocketAdmission`/`requestAdmission`), keeping surface mode's strict
+     * authority validation. Until then every handler here is read-only.
      */
     async createShellSurface() {
         return {
@@ -134,9 +208,9 @@ export class WccDevServer {
             securityHeaders,
         };
     }
-    async readProjectName(cwdArg) {
-        const packageJson = JSON.parse(await plugins.fs.readFile(plugins.path.join(cwdArg, 'package.json'), 'utf8'));
-        return packageJson.name ?? plugins.path.basename(cwdArg);
+    async readProjectName() {
+        const packageJson = JSON.parse(await plugins.fs.readFile(plugins.path.join(this.cwd, 'package.json'), 'utf8'));
+        return packageJson.name ?? plugins.path.basename(this.cwd);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/cli.js

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import { commitinfo } from './00_commitinfo_data.js';
 import { WccDevServer } from './classes.devserver.js';
+import { StandardConfigError, StandardUsageError, registerStandardCommands } from './standards/index.js';
 /**
  * Registers the wcctools commands on the given console.
  */
@@ -20,10 +21,14 @@ export const registerCommands = (out) => {
             },
         },
     }, async ({ options }) => {
-        const devServer = new WccDevServer({ port: options.port });
+        const devServer = new WccDevServer({ port: options.port, cwd: process.cwd() });
+        // The entry point owns process signals: SIGINT and SIGTERM run every registered cleanup, the
+        // dev server's stop among them, once within tswatch's shutdown deadline, then exit.
+        plugins.smartexit.ProcessLifecycle.install({ shutdownTimeoutMs: devServer.getShutdownTimeoutMs() });
         const address = await devServer.start();
         await out.log(`wcctools dev: ${address.url}`);
     });
+    registerStandardCommands(out);
     out.cli.default({}, async () => {
         await out.log(out.cli.renderHelp());
     });
@@ -36,10 +41,14 @@ export const runCli = async () => {
     }
     catch (error) {
         await out.error(error instanceof Error ? error.message : String(error));
-        process.exitCode = 1;
+        // Configuration and usage errors exit with 2, every other failure with 1.
+        const usageError = error instanceof plugins.smartconsole.CliUsageError
+            || error instanceof StandardConfigError
+            || error instanceof StandardUsageError;
+        process.exitCode = usageError ? 2 : 1;
     }
     finally {
         await out.dispose();
     }
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvY2xpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNyRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFdEQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLEdBQXNDLEVBQVEsRUFBRTtJQUMvRSxHQUFHLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQztRQUNoQixJQUFJLEVBQUUsVUFBVTtRQUNoQixPQUFPLEVBQUUsVUFBVSxDQUFDLE9BQU87UUFDM0IsV0FBVyxFQUFFLHVEQUF1RDtLQUNyRSxDQUFDLENBQUM7SUFFSCxHQUFHLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQztRQUNkLElBQUksRUFBRSxLQUFLO1FBQ1gsV0FBVyxFQUFFLHdFQUF3RTtRQUNyRixPQUFPLEVBQUU7WUFDUCxJQUFJLEVBQUU7Z0JBQ0osSUFBSSxFQUFFLFFBQVE7Z0JBQ2QsV0FBVyxFQUFFLDhFQUE4RTthQUM1RjtTQUNGO0tBQ0YsRUFBRSxLQUFLLEVBQUUsRUFBRSxPQUFPLEVBQUUsRUFBRSxFQUFFO1FBQ3ZCLE1BQU0sU0FBUyxHQUFHLElBQUksWUFBWSxDQUFDLEVBQUUsSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQzNELE1BQU0sT0FBTyxHQUFHLE1BQU0sU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3hDLE1BQU0sR0FBRyxDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUM7SUFDaEQsQ0FBQyxDQUFDLENBQUM7SUFFSCxHQUFHLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxFQUFFLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDN0IsTUFBTSxHQUFHLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztJQUN0QyxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxLQUFLLElBQUksRUFBRTtJQUMvQixNQUFNLEdBQUcsR0FBRyxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDcEQsSUFBSSxDQUFDO1FBQ0gsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDdEIsTUFBTSxHQUFHLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQ3RCLENBQUM7SUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1FBQ2YsTUFBTSxHQUFHLENBQUMsS0FBSyxDQUFDLEtBQUssWUFBWSxLQUFLLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQ3hFLE9BQU8sQ0FBQyxRQUFRLEdBQUcsQ0FBQyxDQUFDO0lBQ3ZCLENBQUM7WUFBUyxDQUFDO1FBQ1QsTUFBTSxHQUFHLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDdEIsQ0FBQztBQUNILENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -1,3 +1 @@
 export { runCli } from './cli.js';
-export { WccDevServer, type IWccDevServerOptions, type IWccDevServerAddress } from './classes.devserver.js';
-export { WccDevApi } from './classes.devapi.js';

package/dist_ts/index.js

@@ -1,4 +1,2 @@
 export { runCli } from './cli.js';
-export { WccDevServer } from './classes.devserver.js';
-export { WccDevApi } from './classes.devapi.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ2xDLE9BQU8sRUFBRSxZQUFZLEVBQXdELE1BQU0sd0JBQXdCLENBQUM7QUFDNUcsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sVUFBVSxDQUFDIn0=

package/dist_ts/plugins.d.ts

@@ -1,15 +1,20 @@
+import * as childProcess from 'node:child_process';
 import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
 import * as path from 'node:path';
 import * as url from 'node:url';
-export { fs, path, url };
+export { childProcess, fs, fsSync, path, url };
 import * as typedrequest from '@api.global/typedrequest';
 import * as typedserver from '@api.global/typedserver';
 export { typedrequest, typedserver };
 import * as tswatch from '@git.zone/tswatch';
 export { tswatch };
+import * as smartconfig from '@push.rocks/smartconfig';
 import * as smartconsole from '@push.rocks/smartconsole';
 import * as smartexit from '@push.rocks/smartexit';
-export { smartconsole, smartexit };
+export { smartconfig, smartconsole, smartexit };
+import typescript from 'typescript';
+export { typescript };
 import * as interfaces from '../dist_ts_interfaces/index.js';
 import * as shared from '../dist_ts_shared/index.js';
 export { interfaces, shared };

package/dist_ts/plugins.js

@@ -1,8 +1,10 @@
 // node native scope
+import * as childProcess from 'node:child_process';
 import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
 import * as path from 'node:path';
 import * as url from 'node:url';
-export { fs, path, url };
+export { childProcess, fs, fsSync, path, url };
 // @api.global scope
 import * as typedrequest from '@api.global/typedrequest';
 import * as typedserver from '@api.global/typedserver';
@@ -11,11 +13,15 @@ export { typedrequest, typedserver };
 import * as tswatch from '@git.zone/tswatch';
 export { tswatch };
 // @push.rocks scope
+import * as smartconfig from '@push.rocks/smartconfig';
 import * as smartconsole from '@push.rocks/smartconsole';
 import * as smartexit from '@push.rocks/smartexit';
-export { smartconsole, smartexit };
+export { smartconfig, smartconsole, smartexit };
+// third party scope
+import typescript from 'typescript';
+export { typescript };
 // project scope
 import * as interfaces from '../dist_ts_interfaces/index.js';
 import * as shared from '../dist_ts_shared/index.js';
 export { interfaces, shared };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDdkMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFFaEMsT0FBTyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFekIsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUV2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBRSxDQUFDO0FBRXJDLGtCQUFrQjtBQUNsQixPQUFPLEtBQUssT0FBTyxNQUFNLG1CQUFtQixDQUFDO0FBRTdDLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUVuQixvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxZQUFZLEVBQUUsU0FBUyxFQUFFLENBQUM7QUFFbkMsZ0JBQWdCO0FBQ2hCLE9BQU8sS0FBSyxVQUFVLE1BQU0sMkJBQTJCLENBQUM7QUFDeEQsT0FBTyxLQUFLLE1BQU0sTUFBTSx1QkFBdUIsQ0FBQztBQUVoRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssTUFBTSxNQUFNLFNBQVMsQ0FBQztBQUNsQyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEtBQUssR0FBRyxNQUFNLFVBQVUsQ0FBQztBQUVoQyxPQUFPLEVBQUUsWUFBWSxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxDQUFDO0FBRS9DLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFFdkQsT0FBTyxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsQ0FBQztBQUVyQyxrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxtQkFBbUIsQ0FBQztBQUU3QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxDQUFDO0FBRWhELG9CQUFvQjtBQUNwQixPQUFPLFVBQVUsTUFBTSxZQUFZLENBQUM7QUFFcEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDO0FBRXRCLGdCQUFnQjtBQUNoQixPQUFPLEtBQUssVUFBVSxNQUFNLDJCQUEyQixDQUFDO0FBQ3hELE9BQU8sS0FBSyxNQUFNLE1BQU0sdUJBQXVCLENBQUM7QUFFaEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsQ0FBQyJ9

package/dist_ts/standards/baselines.d.ts

@@ -0,0 +1,27 @@
+import * as plugins from '../plugins.js';
+type IStandardConfig = plugins.interfaces.IStandardConfig;
+type IStandardReport = plugins.interfaces.IStandardReport;
+type TBaselines = NonNullable<IStandardConfig['baselines']>;
+/** `--init-baseline`: the current error counts of every rule. Only valid while the configuration has no baselines. */
+export declare const initialBaselines: (reportArg: IStandardReport) => TBaselines;
+export interface IBaselineRaise {
+    ruleId: string;
+    file: string;
+    baseline: number;
+    current: number;
+}
+/**
+ * `--update-baseline`: lowers every count to the current one and removes entries that reach 0.
+ * `raised` lists every file whose count would have to grow, including files without an entry;
+ * when it is not empty the update is refused.
+ */
+export declare const updatedBaselines: (reportArg: IStandardReport, baselinesArg: TBaselines) => {
+    baselines: TBaselines;
+    raised: IBaselineRaise[];
+};
+/** The configuration with allowlist and baseline file paths moved along with `wcctools fix` moves. */
+export declare const rekeyStandardConfig: (configArg: IStandardConfig, movesArg: readonly plugins.interfaces.IStandardFileMove[]) => {
+    config: IStandardConfig;
+    changed: string[];
+};
+export {};

package/dist_ts/standards/baselines.js

@@ -0,0 +1,83 @@
+import * as plugins from '../plugins.js';
+import { allowlistStaleRuleId } from './rules/index.js';
+/**
+ * Baseline arithmetic of the ratchet. Pure functions: persisting the result goes through
+ * IStandardConfigWriter (see config.ts).
+ */
+/** Per rule and file, the error findings a baseline would have to accept (allowlisted findings excluded). */
+const errorCounts = (reportArg) => {
+    const counts = {};
+    for (const finding of reportArg.findings) {
+        if (finding.severity !== 'error' || finding.covered === 'allowlist' || finding.ruleId === allowlistStaleRuleId) {
+            continue;
+        }
+        counts[finding.ruleId] ??= {};
+        counts[finding.ruleId][finding.file] = (counts[finding.ruleId][finding.file] ?? 0) + 1;
+    }
+    return counts;
+};
+const sortBaselines = (baselinesArg) => {
+    const sorted = {};
+    for (const ruleId of Object.keys(baselinesArg).sort()) {
+        const files = Object.keys(baselinesArg[ruleId]).sort();
+        if (files.length > 0) {
+            sorted[ruleId] = Object.fromEntries(files.map((fileArg) => [fileArg, baselinesArg[ruleId][fileArg]]));
+        }
+    }
+    return sorted;
+};
+/** `--init-baseline`: the current error counts of every rule. Only valid while the configuration has no baselines. */
+export const initialBaselines = (reportArg) => sortBaselines(errorCounts(reportArg));
+/**
+ * `--update-baseline`: lowers every count to the current one and removes entries that reach 0.
+ * `raised` lists every file whose count would have to grow, including files without an entry;
+ * when it is not empty the update is refused.
+ */
+export const updatedBaselines = (reportArg, baselinesArg) => {
+    const current = errorCounts(reportArg);
+    const raised = [];
+    const baselines = {};
+    for (const [ruleId, counts] of Object.entries(baselinesArg)) {
+        baselines[ruleId] = {};
+        for (const [file, baseline] of Object.entries(counts)) {
+            const count = current[ruleId]?.[file] ?? 0;
+            if (count > baseline) {
+                raised.push({ ruleId, file, baseline, current: count });
+            }
+            else if (count > 0) {
+                baselines[ruleId][file] = count;
+            }
+        }
+    }
+    for (const [ruleId, counts] of Object.entries(current)) {
+        for (const [file, count] of Object.entries(counts)) {
+            if (baselinesArg[ruleId]?.[file] === undefined) {
+                raised.push({ ruleId, file, baseline: 0, current: count });
+            }
+        }
+    }
+    return { baselines: sortBaselines(baselines), raised };
+};
+/** The configuration with allowlist and baseline file paths moved along with `wcctools fix` moves. */
+export const rekeyStandardConfig = (configArg, movesArg) => {
+    const moved = new Map(movesArg.map((moveArg) => [moveArg.from, moveArg.to]));
+    const changed = [];
+    const rekey = (keyArg) => {
+        const [file, ...member] = keyArg.split('#');
+        const target = moved.get(file);
+        if (!target) {
+            return keyArg;
+        }
+        changed.push(keyArg);
+        return [target, ...member].join('#');
+    };
+    const config = { ...configArg };
+    if (configArg.allowlist) {
+        config.allowlist = Object.fromEntries(Object.entries(configArg.allowlist).map(([ruleId, entries]) => [ruleId, Object.fromEntries(Object.entries(entries).map(([key, value]) => [rekey(key), value]))]));
+    }
+    if (configArg.baselines) {
+        config.baselines = Object.fromEntries(Object.entries(configArg.baselines).map(([ruleId, counts]) => [ruleId, Object.fromEntries(Object.entries(counts).map(([file, count]) => [rekey(file), count]))]));
+    }
+    return { config, changed };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZWxpbmVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvc3RhbmRhcmRzL2Jhc2VsaW5lcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQU14RDs7O0dBR0c7QUFFSCw2R0FBNkc7QUFDN0csTUFBTSxXQUFXLEdBQUcsQ0FBQyxTQUEwQixFQUFjLEVBQUU7SUFDN0QsTUFBTSxNQUFNLEdBQWUsRUFBRSxDQUFDO0lBQzlCLEtBQUssTUFBTSxPQUFPLElBQUksU0FBUyxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ3pDLElBQUksT0FBTyxDQUFDLFFBQVEsS0FBSyxPQUFPLElBQUksT0FBTyxDQUFDLE9BQU8sS0FBSyxXQUFXLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxvQkFBb0IsRUFBRSxDQUFDO1lBQy9HLFNBQVM7UUFDWCxDQUFDO1FBQ0QsTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDOUIsTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDekYsQ0FBQztJQUNELE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMsQ0FBQztBQUVGLE1BQU0sYUFBYSxHQUFHLENBQUMsWUFBd0IsRUFBYyxFQUFFO0lBQzdELE1BQU0sTUFBTSxHQUFlLEVBQUUsQ0FBQztJQUM5QixLQUFLLE1BQU0sTUFBTSxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQztRQUN0RCxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3ZELElBQUksS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNyQixNQUFNLENBQUMsTUFBTSxDQUFDLEdBQUcsTUFBTSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE9BQU8sRUFBRSxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDeEcsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDLENBQUM7QUFFRixzSEFBc0g7QUFDdEgsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsQ0FBQyxTQUEwQixFQUFjLEVBQUUsQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7QUFTbEg7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsU0FBMEIsRUFBRSxZQUF3QixFQUF1RCxFQUFFO0lBQzVJLE1BQU0sT0FBTyxHQUFHLFdBQVcsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUN2QyxNQUFNLE1BQU0sR0FBcUIsRUFBRSxDQUFDO0lBQ3BDLE1BQU0sU0FBUyxHQUFlLEVBQUUsQ0FBQztJQUNqQyxLQUFLLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsRUFBRSxDQUFDO1FBQzVELFNBQVMsQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDdkIsS0FBSyxNQUFNLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUN0RCxNQUFNLEtBQUssR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDM0MsSUFBSSxLQUFLLEdBQUcsUUFBUSxFQUFFLENBQUM7Z0JBQ3JCLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQztZQUMxRCxDQUFDO2lCQUFNLElBQUksS0FBSyxHQUFHLENBQUMsRUFBRSxDQUFDO2dCQUNyQixTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsS0FBSyxDQUFDO1lBQ2xDLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztJQUNELEtBQUssTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7UUFDdkQsS0FBSyxNQUFNLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUNuRCxJQUFJLFlBQVksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLFNBQVMsRUFBRSxDQUFDO2dCQUMvQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO1lBQzdELENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztJQUNELE9BQU8sRUFBRSxTQUFTLEVBQUUsYUFBYSxDQUFDLFNBQVMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBQ3pELENBQUMsQ0FBQztBQUVGLHNHQUFzRztBQUN0RyxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUFDLFNBQTBCLEVBQUUsUUFBeUQsRUFBa0QsRUFBRTtJQUMzSyxNQUFNLEtBQUssR0FBRyxJQUFJLEdBQUcsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM3RSxNQUFNLE9BQU8sR0FBYSxFQUFFLENBQUM7SUFDN0IsTUFBTSxLQUFLLEdBQUcsQ0FBQyxNQUFjLEVBQVUsRUFBRTtRQUN2QyxNQUFNLENBQUMsSUFBSSxFQUFFLEdBQUcsTUFBTSxDQUFDLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUM1QyxNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQy9CLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNaLE9BQU8sTUFBTSxDQUFDO1FBQ2hCLENBQUM7UUFDRCxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3JCLE9BQU8sQ0FBQyxNQUFNLEVBQUUsR0FBRyxNQUFNLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDdkMsQ0FBQyxDQUFDO0lBQ0YsTUFBTSxNQUFNLEdBQW9CLEVBQUUsR0FBRyxTQUFTLEVBQUUsQ0FBQztJQUNqRCxJQUFJLFNBQVMsQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUN4QixNQUFNLENBQUMsU0FBUyxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUNsRyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN2RyxDQUFDO0lBQ0QsSUFBSSxTQUFTLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDeEIsTUFBTSxDQUFDLFNBQVMsR0FBRyxNQUFNLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxFQUFFLEVBQUUsQ0FDakcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDeEcsQ0FBQztJQUNELE9BQU8sRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFDN0IsQ0FBQyxDQUFDIn0=

package/dist_ts/standards/checker.d.ts

@@ -0,0 +1,21 @@
+import * as plugins from '../plugins.js';
+import type { StandardProject } from './classes.standardproject.js';
+import type { ILoadedStandardConfig } from './config.js';
+import { type IRuleFinding, type IStandardRule } from './rule.js';
+type IStandardReport = plugins.interfaces.IStandardReport;
+type TStandardProfile = plugins.interfaces.TStandardProfile;
+/** The rules of a profile, in the order of docs/standard.md. */
+export declare const rulesOfProfile: (profileArg: TStandardProfile) => IStandardRule[];
+/** The rules of a profile as the shell and the AI agent see them. */
+export declare const describeStandardRules: (profileArg: TStandardProfile) => plugins.interfaces.IStandardRuleInfo[];
+/** A finding of one rule with its allowlist state. */
+export interface IDetectedFinding {
+    rule: IStandardRule;
+    finding: IRuleFinding;
+    allowlisted: boolean;
+}
+/** Runs the rules of the configured profile; findings carry their fix actions. */
+export declare const detectFindings: (projectArg: StandardProject, loadedArg: ILoadedStandardConfig, rulesArg?: readonly IStandardRule[]) => IDetectedFinding[];
+/** Checks a repository against the standard: findings, allowlist, baselines. */
+export declare const checkStandard: (projectArg: StandardProject, loadedArg: ILoadedStandardConfig) => IStandardReport;
+export {};

package/dist_ts/standards/checker.js

@@ -0,0 +1,88 @@
+import * as plugins from '../plugins.js';
+import { severityIn } from './rule.js';
+import { allowlistStaleRuleId, standardRules } from './rules/index.js';
+/** The rules of a profile, in the order of docs/standard.md. */
+export const rulesOfProfile = (profileArg) => standardRules.filter((ruleArg) => severityIn(ruleArg, profileArg) !== null);
+/** The rules of a profile as the shell and the AI agent see them. */
+export const describeStandardRules = (profileArg) => rulesOfProfile(profileArg).map((ruleArg) => ({
+    id: ruleArg.id,
+    severity: severityIn(ruleArg, profileArg),
+    fixMode: ruleArg.fixMode,
+    allowlistCategories: [...(ruleArg.allowlistCategories ?? [])],
+}));
+/** Runs the rules of the configured profile; findings carry their fix actions. */
+export const detectFindings = (projectArg, loadedArg, rulesArg = rulesOfProfile(loadedArg.profile)) => {
+    const context = { project: projectArg, config: loadedArg.config, profile: loadedArg.profile };
+    const detected = [];
+    for (const rule of rulesArg) {
+        const allowlist = loadedArg.config.allowlist?.[rule.id] ?? {};
+        for (const finding of rule.detect(context)) {
+            detected.push({ rule, finding, allowlisted: Object.hasOwn(allowlist, finding.key) });
+        }
+    }
+    return detected;
+};
+const locate = (projectArg, fileArg, positionArg) => {
+    const text = projectArg.files.get(fileArg);
+    if (text === undefined) {
+        return { line: 1, column: 1 };
+    }
+    if (/\.(ts|tsx|mts|cts)$/.test(fileArg)) {
+        return projectArg.lineAndColumn(fileArg, positionArg);
+    }
+    const before = text.slice(0, positionArg);
+    return { line: before.split('\n').length, column: positionArg - before.lastIndexOf('\n') };
+};
+/** Checks a repository against the standard: findings, allowlist, baselines. */
+export const checkStandard = (projectArg, loadedArg) => {
+    const { config, profile } = loadedArg;
+    const detected = detectFindings(projectArg, loadedArg);
+    const findings = detected.map(({ rule, finding, allowlisted }) => ({
+        ruleId: rule.id,
+        severity: severityIn(rule, profile),
+        file: finding.file,
+        ...locate(projectArg, finding.file, finding.position),
+        message: finding.message,
+        fixable: !!finding.fix,
+        ...(allowlisted ? { covered: 'allowlist' } : {}),
+    }));
+    // An allowlist entry without its finding is stale: the list only shrinks.
+    for (const [ruleId, entries] of Object.entries(config.allowlist ?? {})) {
+        for (const key of Object.keys(entries)) {
+            if (!detected.some(({ rule, finding }) => rule.id === ruleId && finding.key === key)) {
+                findings.push({
+                    ruleId: allowlistStaleRuleId,
+                    severity: 'error',
+                    file: '.smartconfig.json',
+                    line: 1,
+                    column: 1,
+                    message: `the ${ruleId} allowlist entry '${key}' matches no finding; remove it`,
+                    fixable: false,
+                });
+            }
+        }
+    }
+    // Baselines: per rule and file, a count at or below the baseline is covered; above it nothing is.
+    const baselineSlack = [];
+    for (const [ruleId, counts] of Object.entries(config.baselines ?? {})) {
+        for (const [file, baseline] of Object.entries(counts)) {
+            const inFile = findings.filter((findingArg) => findingArg.ruleId === ruleId && findingArg.file === file && !findingArg.covered);
+            if (inFile.length <= baseline) {
+                inFile.forEach((findingArg) => {
+                    findingArg.covered = 'baseline';
+                });
+            }
+            if (inFile.length < baseline) {
+                baselineSlack.push({ ruleId, file, baseline, current: inFile.length });
+            }
+        }
+    }
+    findings.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column || a.ruleId.localeCompare(b.ruleId));
+    return {
+        profile,
+        findings,
+        baselineSlack,
+        ok: !findings.some((findingArg) => findingArg.severity === 'error' && !findingArg.covered),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/standards/classes.gitrepo.d.ts

@@ -0,0 +1,13 @@
+/** The git operations `wcctools fix` needs, run with an argument vector and no shell. */
+export declare class GitRepo {
+    readonly rootDir: string;
+    constructor(rootDirArg: string);
+    run(argsArg: string[]): Promise<string>;
+    /** The repository's top-level directory, or null when the directory is not inside a git work tree. */
+    topLevel(): Promise<string | null>;
+    /** `git status --porcelain` lines; empty for a clean tree (untracked files count as changes). */
+    statusLines(): Promise<string[]>;
+    /** Tracked files, relative to the repository root. */
+    trackedFiles(): Promise<string[]>;
+    move(fromArg: string, toArg: string): Promise<void>;
+}