@git.zone/tstest 6.0.0 → 6.1.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/tstest',
-    version: '6.0.0',
+    version: '6.1.0',
     description: 'A powerful, modern test runner for TypeScript with multi-runtime support (Node.js, Deno, Bun, Chromium) and a batteries-included test framework.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGtKQUFrSjtDQUNoSyxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -1,3 +1,6 @@
+export * from './tstest.interfaces.config.js';
+export { artifactPaths, cleanArtifacts, defaultCleanupArtifacts, formatBytes, resolveCleanupTargets, } from './tstest.classes.artifacts.js';
+export { cleanupRunsAfterTests, cleanupRunsOnRelease, loadTstestConfig, } from './tstest.classes.config.js';
 export declare enum TestExecutionMode {
     DIRECTORY = "directory",
     FILE = "file",

package/dist_ts/index.js

@@ -1,4 +1,9 @@
 import { TsTest } from './tstest.classes.tstest.js';
+import { loadTstestConfig } from './tstest.classes.config.js';
+import { cleanArtifacts, formatBytes, resolveCleanupTargets, } from './tstest.classes.artifacts.js';
+export * from './tstest.interfaces.config.js';
+export { artifactPaths, cleanArtifacts, defaultCleanupArtifacts, formatBytes, resolveCleanupTargets, } from './tstest.classes.artifacts.js';
+export { cleanupRunsAfterTests, cleanupRunsOnRelease, loadTstestConfig, } from './tstest.classes.config.js';
 export var TestExecutionMode;
 (function (TestExecutionMode) {
     TestExecutionMode["DIRECTORY"] = "directory";
@@ -40,6 +45,30 @@ export const runCli = async () => {
     }
     // Parse command line arguments
     const args = process.argv.slice(2);
+    // `tstest clean` removes the artifacts tstest wrote, per .smartconfig.json.
+    if (args[0] === 'clean') {
+        const dryRun = args.includes('--dry-run');
+        const cwd = process.cwd();
+        const config = loadTstestConfig(cwd);
+        if (dryRun) {
+            const { targets } = resolveCleanupTargets(cwd, config.cleanup);
+            console.log('tstest clean (dry run) would remove:');
+            for (const target of targets) {
+                console.log(`  ${target}`);
+            }
+            return;
+        }
+        const result = cleanArtifacts(cwd, config);
+        if (result.removed.length === 0) {
+            console.log('tstest clean: nothing to remove');
+            return;
+        }
+        for (const entry of result.removed) {
+            console.log(`  removed ${entry.path} (${formatBytes(entry.bytes)})`);
+        }
+        console.log(`tstest clean: reclaimed ${formatBytes(result.totalBytes)}`);
+        return;
+    }
     const logOptions = {};
     let testPath = null;
     let tags = [];
@@ -157,6 +186,7 @@ export const runCli = async () => {
     if (!testPath) {
         console.error('You must specify a test directory/file/pattern as argument. Please try again.');
         console.error('\nUsage: tstest <path> [options]');
+        console.error('       tstest clean [--dry-run]');
         console.error('\nOptions:');
         console.error('  --version         Show version information');
         console.error('  --quiet, -q       Minimal output');
@@ -170,6 +200,9 @@ export const runCli = async () => {
         console.error('  --timeout <s>     Timeout test files after s seconds');
         console.error('  --watch, -w       Watch for file changes and re-run tests');
         console.error('  --watch-ignore    Patterns to ignore in watch mode (comma-separated)');
+        console.error('\nCleanup:');
+        console.error('  clean             Remove test artifacts (.nogit/testlogs, tstest_cache, testfiles)');
+        console.error('  clean --dry-run   Show what would be removed without removing it');
         process.exit(1);
     }
     let executionMode;
@@ -196,4 +229,4 @@ export const runCli = async () => {
 if (import.meta.url === `file://${process.argv[1]}`) {
     runCli();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}

package/dist_ts/tstest.classes.artifacts.d.ts

@@ -0,0 +1,32 @@
+import type { ITstestCleanupConfig, ITstestConfig, TTstestArtifact } from './tstest.interfaces.config.js';
+/**
+ * Every location tstest writes to, keyed by artifact group. Keeping this in
+ * one place is what makes cleanup complete: a new write location must be
+ * registered here, not scattered through the runtimes.
+ */
+export declare const artifactPaths: Record<TTstestArtifact, string>;
+/**
+ * Removed unless a project opts in. Snapshots are excluded because they are
+ * assertion baselines rather than output - see ITstestCleanupConfig.artifacts.
+ */
+export declare const defaultCleanupArtifacts: TTstestArtifact[];
+export interface IRemovedArtifact {
+    path: string;
+    bytes: number;
+}
+export interface ICleanupResult {
+    removed: IRemovedArtifact[];
+    totalBytes: number;
+}
+/** Human-readable byte size, so cleanup output states what it reclaimed. */
+export declare const formatBytes: (bytes: number) => string;
+/** The concrete paths a cleanup would remove, after validation. */
+export declare const resolveCleanupTargets: (cwd: string, cleanupConfig?: ITstestCleanupConfig) => {
+    targets: string[];
+    rejected: string[];
+};
+/**
+ * Remove the configured artifacts. Missing paths are not an error - cleanup
+ * is expected to run on projects that never produced some of them.
+ */
+export declare const cleanArtifacts: (cwd: string, config?: ITstestConfig) => ICleanupResult;

package/dist_ts/tstest.classes.artifacts.js

@@ -0,0 +1,144 @@
+import * as plugins from './tstest.plugins.js';
+/**
+ * Every location tstest writes to, keyed by artifact group. Keeping this in
+ * one place is what makes cleanup complete: a new write location must be
+ * registered here, not scattered through the runtimes.
+ */
+export const artifactPaths = {
+    logs: plugins.path.join('.nogit', 'testlogs'),
+    cache: plugins.path.join('.nogit', 'tstest_cache'),
+    testfiles: plugins.path.join('.nogit', 'testfiles'),
+    snapshots: plugins.path.join('.nogit', 'test_snapshots'),
+};
+/**
+ * Removed unless a project opts in. Snapshots are excluded because they are
+ * assertion baselines rather than output - see ITstestCleanupConfig.artifacts.
+ */
+export const defaultCleanupArtifacts = ['logs', 'cache', 'testfiles'];
+/** Human-readable byte size, so cleanup output states what it reclaimed. */
+export const formatBytes = (bytes) => {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let value = bytes / 1024;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex++;
+    }
+    // One decimal below 10 keeps small differences visible; above that the
+    // fraction is noise.
+    return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unitIndex]}`;
+};
+const directorySize = (absolutePath) => {
+    let total = 0;
+    const walk = (current) => {
+        let entries;
+        try {
+            entries = plugins.fs.readdirSync(current);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const entryPath = plugins.path.join(current, entry);
+            let stat;
+            try {
+                stat = plugins.fs.lstatSync(entryPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                walk(entryPath);
+            }
+            else {
+                total += stat.size;
+            }
+        }
+    };
+    try {
+        const stat = plugins.fs.lstatSync(absolutePath);
+        if (stat.isDirectory()) {
+            walk(absolutePath);
+        }
+        else {
+            total = stat.size;
+        }
+    }
+    catch {
+        return 0;
+    }
+    return total;
+};
+/**
+ * Resolve a configured relative path against the project root, refusing
+ * anything that escapes it. Cleanup deletes recursively, so an unchecked
+ * `../..` here would be destructive.
+ */
+const resolveInsideProject = (cwd, candidate) => {
+    if (plugins.path.isAbsolute(candidate)) {
+        return null;
+    }
+    const resolvedRoot = plugins.path.resolve(cwd);
+    const resolved = plugins.path.resolve(resolvedRoot, candidate);
+    if (resolved === resolvedRoot) {
+        return null;
+    }
+    const withSeparator = resolvedRoot.endsWith(plugins.path.sep)
+        ? resolvedRoot
+        : `${resolvedRoot}${plugins.path.sep}`;
+    return resolved.startsWith(withSeparator) ? resolved : null;
+};
+/** The concrete paths a cleanup would remove, after validation. */
+export const resolveCleanupTargets = (cwd, cleanupConfig = {}) => {
+    const artifacts = cleanupConfig.artifacts ?? defaultCleanupArtifacts;
+    const targets = [];
+    const rejected = [];
+    for (const artifact of artifacts) {
+        const relativePath = artifactPaths[artifact];
+        if (!relativePath) {
+            rejected.push(String(artifact));
+            continue;
+        }
+        targets.push(plugins.path.resolve(cwd, relativePath));
+    }
+    for (const additional of cleanupConfig.additionalPaths ?? []) {
+        const resolved = resolveInsideProject(cwd, additional);
+        if (!resolved) {
+            rejected.push(additional);
+            continue;
+        }
+        targets.push(resolved);
+    }
+    return { targets, rejected };
+};
+/**
+ * Remove the configured artifacts. Missing paths are not an error - cleanup
+ * is expected to run on projects that never produced some of them.
+ */
+export const cleanArtifacts = (cwd, config = {}) => {
+    const { targets, rejected } = resolveCleanupTargets(cwd, config.cleanup);
+    for (const badPath of rejected) {
+        console.error(`tstest cleanup: refusing "${badPath}" - additionalPaths must be relative and stay inside the project`);
+    }
+    const removed = [];
+    let totalBytes = 0;
+    for (const target of targets) {
+        if (!plugins.fs.existsSync(target)) {
+            continue;
+        }
+        const bytes = directorySize(target);
+        try {
+            plugins.fs.rmSync(target, { recursive: true, force: true });
+        }
+        catch (error) {
+            console.error(`tstest cleanup: could not remove ${target}: ${error}`);
+            continue;
+        }
+        removed.push({ path: plugins.path.relative(cwd, target) || target, bytes });
+        totalBytes += bytes;
+    }
+    return { removed, totalBytes };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tstest.classes.beforescripts.d.ts

@@ -7,7 +7,9 @@ export interface IBeforeScripts {
     beforeTestfile: string | null;
 }
 /**
- * Load before-script commands from the project's package.json scripts section.
+ * Load before-script commands. `.smartconfig.json`'s `@git.zone/tstest`
+ * prepare block wins; the package.json `test:before*` scripts remain
+ * supported so existing projects keep working.
  */
 export declare function loadBeforeScripts(cwd: string): IBeforeScripts;
 /**

package/dist_ts/tstest.classes.beforescripts.js

@@ -1,9 +1,20 @@
 import * as plugins from './tstest.plugins.js';
+import { loadTstestConfig } from './tstest.classes.config.js';
 /**
- * Load before-script commands from the project's package.json scripts section.
+ * Load before-script commands. `.smartconfig.json`'s `@git.zone/tstest`
+ * prepare block wins; the package.json `test:before*` scripts remain
+ * supported so existing projects keep working.
  */
 export function loadBeforeScripts(cwd) {
     const result = { beforeOnce: null, beforeTestfile: null };
+    const prepareConfig = loadTstestConfig(cwd).prepare;
+    if (prepareConfig?.once)
+        result.beforeOnce = prepareConfig.once;
+    if (prepareConfig?.perTestfile)
+        result.beforeTestfile = prepareConfig.perTestfile;
+    if (result.beforeOnce && result.beforeTestfile) {
+        return result;
+    }
     try {
         const packageJsonPath = plugins.path.join(cwd, 'package.json');
         const packageJson = JSON.parse(plugins.fs.readFileSync(packageJsonPath, 'utf8'));
@@ -11,7 +22,10 @@ export function loadBeforeScripts(cwd) {
         if (!scripts)
             return result;
         // test:before takes precedence over test:before:once (they are aliases)
-        if (scripts['test:before']) {
+        if (result.beforeOnce) {
+            // already provided by .smartconfig.json
+        }
+        else if (scripts['test:before']) {
             result.beforeOnce = scripts['test:before'];
             if (scripts['test:before:once']) {
                 console.warn('Warning: Both "test:before" and "test:before:once" are defined. Using "test:before".');
@@ -20,7 +34,7 @@ export function loadBeforeScripts(cwd) {
         else if (scripts['test:before:once']) {
             result.beforeOnce = scripts['test:before:once'];
         }
-        if (scripts['test:before:testfile']) {
+        if (!result.beforeTestfile && scripts['test:before:testfile']) {
             result.beforeTestfile = scripts['test:before:testfile'];
         }
     }
@@ -65,4 +79,4 @@ export async function runBeforeScript(smartshellInstance, command, label, logger
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tstest.classes.config.d.ts

@@ -0,0 +1,11 @@
+import type { ITstestConfig } from './tstest.interfaces.config.js';
+/**
+ * Read the `@git.zone/tstest` section of `.smartconfig.json`, following the
+ * same convention as tsbundle, tswatch, tsrust and tsdocker. A project
+ * without the section gets the defaults, so this is safe to call anywhere.
+ */
+export declare const loadTstestConfig: (cwd: string) => ITstestConfig;
+/** Cleanup runs on release unless the project opts out. */
+export declare const cleanupRunsOnRelease: (config: ITstestConfig) => boolean;
+/** Cleanup after a local test run is opt-in. */
+export declare const cleanupRunsAfterTests: (config: ITstestConfig) => boolean;

package/dist_ts/tstest.classes.config.js

@@ -0,0 +1,21 @@
+import * as plugins from './tstest.plugins.js';
+/**
+ * Read the `@git.zone/tstest` section of `.smartconfig.json`, following the
+ * same convention as tsbundle, tswatch, tsrust and tsdocker. A project
+ * without the section gets the defaults, so this is safe to call anywhere.
+ */
+export const loadTstestConfig = (cwd) => {
+    try {
+        const smartconfigInstance = new plugins.smartconfig.Smartconfig(cwd);
+        return smartconfigInstance.dataFor('@git.zone/tstest', {});
+    }
+    catch (error) {
+        console.error(`tstest: could not read .smartconfig.json (${error}); using defaults`);
+        return {};
+    }
+};
+/** Cleanup runs on release unless the project opts out. */
+export const cleanupRunsOnRelease = (config) => config.cleanup?.onRelease !== false;
+/** Cleanup after a local test run is opt-in. */
+export const cleanupRunsAfterTests = (config) => config.cleanup?.afterRun === true;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN0ZXN0LmNsYXNzZXMuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdHN0ZXN0LmNsYXNzZXMuY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFHL0M7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsR0FBVyxFQUFpQixFQUFFO0lBQzdELElBQUksQ0FBQztRQUNILE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxPQUFPLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNyRSxPQUFPLG1CQUFtQixDQUFDLE9BQU8sQ0FBZ0Isa0JBQWtCLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDNUUsQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDZixPQUFPLENBQUMsS0FBSyxDQUFDLDZDQUE2QyxLQUFLLG1CQUFtQixDQUFDLENBQUM7UUFDckYsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0FBQ0gsQ0FBQyxDQUFDO0FBRUYsMkRBQTJEO0FBQzNELE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLENBQUMsTUFBcUIsRUFBVyxFQUFFLENBQ3JFLE1BQU0sQ0FBQyxPQUFPLEVBQUUsU0FBUyxLQUFLLEtBQUssQ0FBQztBQUV0QyxnREFBZ0Q7QUFDaEQsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsQ0FBQyxNQUFxQixFQUFXLEVBQUUsQ0FDdEUsTUFBTSxDQUFDLE9BQU8sRUFBRSxRQUFRLEtBQUssSUFBSSxDQUFDIn0=

package/dist_ts/tstest.classes.tstest.js

@@ -18,6 +18,8 @@ import { DockerRuntimeAdapter } from './tstest.classes.runtime.docker.js';
 import { parseDirectivesFromFile, mergeDirectives, directivesToRuntimeOptions, hasDirectives, } from './tstest.classes.testfile.directives.js';
 // Before-script support
 import { loadBeforeScripts, runBeforeScript } from './tstest.classes.beforescripts.js';
+import { cleanupRunsAfterTests, loadTstestConfig } from './tstest.classes.config.js';
+import { cleanArtifacts, formatBytes } from './tstest.classes.artifacts.js';
 export class TsTest {
     constructor(cwdArg, testPathArg, executionModeArg, logOptions = {}, tags = [], startFromFile = null, stopAtFile = null, timeoutSeconds = null) {
         this.smartshellInstance = new plugins.smartshell.Smartshell({
@@ -102,6 +104,15 @@ export class TsTest {
      */
     async cleanup() {
         this.smartshellInstance.smartexit.deregister();
+        // Opt-in: projects that do not want their test output kept can have it
+        // removed as soon as the run finishes.
+        const config = loadTstestConfig(this.testDir.cwd);
+        if (cleanupRunsAfterTests(config)) {
+            const result = cleanArtifacts(this.testDir.cwd, config);
+            if (result.totalBytes > 0) {
+                console.log(`tstest: cleaned test artifacts, reclaimed ${formatBytes(result.totalBytes)}`);
+            }
+        }
     }
     async runWatch(ignorePatterns = []) {
         const smartwatchInstance = new plugins.smartwatch.Smartwatch([this.testDir.cwd]);
@@ -328,4 +339,4 @@ export class TsTest {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tstest.classes.tstest.js","sourceRoot":"","sources":["../ts/tstest.classes.tstest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,aAAa,IAAI,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,mBAAmB;AACnB,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAClH,OAAO,EAAE,sBAAsB,EAA4C,MAAM,qCAAqC,CAAC;AACvH,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,uBAAuB;AACvB,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,0BAA0B,EAC1B,aAAa,GACd,MAAM,yCAAyC,CAAC;AAEjD,wBAAwB;AACxB,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAuB,MAAM,mCAAmC,CAAC;AAE5G,MAAM,OAAO,MAAM;IAuBjB,YAAY,MAAc,EAAE,WAAmB,EAAE,gBAAmC,EAAE,aAAyB,EAAE,EAAE,OAAiB,EAAE,EAAE,gBAA+B,IAAI,EAAE,aAA4B,IAAI,EAAE,iBAAgC,IAAI;QAd5O,uBAAkB,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC;YAC5D,QAAQ,EAAE,MAAM;YAChB,eAAe,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC;YACrC,eAAe,EAAE,EAAE;SACpB,CAAC,CAAC;QACI,yBAAoB,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;QAE/D,qBAAgB,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAEnD,oBAAe,GAAG,IAAI,sBAAsB,EAAE,CAAC;QAC/C,kBAAa,GAAgC,IAAI,CAAC;QAEjD,kBAAa,GAA0B,IAAI,CAAC;QAGlD,IAAI,CAAC,aAAa,GAAG,gBAAgB,CAAC;QACtC,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAC,MAAM,EAAE,WAAW,EAAE,gBAAgB,CAAC,CAAC;QACxE,IAAI,CAAC,MAAM,GAAG,IAAI,YAAY,CAAC,UAAU,CAAC,CAAC;QAC3C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QAErC,4BAA4B;QAC5B,IAAI,CAAC,eAAe,CAAC,QAAQ,CAC3B,IAAI,kBAAkB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC,CACnG,CAAC;QACF,IAAI,CAAC,eAAe,CAAC,QAAQ,CAC3B,IAAI,sBAAsB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,oBAAoB,EAAE,IAAI,CAAC,cAAc,CAAC,CAC/G,CAAC;QACF,IAAI,CAAC,eAAe,CAAC,QAAQ,CAC3B,IAAI,kBAAkB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC,CACnG,CAAC;QACF,IAAI,CAAC,eAAe,CAAC,QAAQ,CAC3B,IAAI,iBAAiB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC,CAClG,CAAC;QAEF,4BAA4B;QAC5B,IAAI,CAAC,aAAa,GAAG,IAAI,oBAAoB,CAC3C,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,cAAc,EACnB,MAAM,CACP,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB;QAC5B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,CAAC;QACpE,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAC3C,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,GAAG;QACP,gCAAgC;QAChC,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAE9B,sDAAsD;QACtD,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAChC,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACpC,CAAC;QAED,+DAA+D;QAC/D,IAAI,CAAC,aAAa,GAAG,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACzD,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC;YAClC,MAAM,OAAO,GAAG,MAAM,eAAe,CACnC,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,aAAa,CAAC,UAAU,EAC7B,aAAa,EACb,IAAI,CAAC,MAAM,CACZ,CAAC;YACF,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,+CAA+C,CAAC,CAAC;gBACnE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC;QACH,CAAC;QAED,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAC1D,MAAM,QAAQ,GAAG,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAE5F,8CAA8C;QAC9C,IAAI,CAAC,MAAM,CAAC,aAAa,CACvB,QAAQ,CAAC,MAAM,EACf,IAAI,CAAC,OAAO,CAAC,QAAQ,EACrB,IAAI,CAAC,aAAa,CACnB,CAAC;QAEF,MAAM,aAAa,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,gCAAgC;QACtF,IAAI,SAAS,GAAG,CAAC,CAAC;QAElB,6BAA6B;QAC7B,KAAK,MAAM,WAAW,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;YAC5C,SAAS,EAAE,CAAC;YACZ,MAAM,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QACzF,CAAC;QAED,uCAAuC;QACvC,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,IAAI,EAAE,CAAC;QACjE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,UAAU,GAAG,UAAU,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;YAExD,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC1B,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,mBAAmB,SAAS,EAAE,CAAC,CAAC;gBAEzD,0CAA0C;gBAC1C,MAAM,gBAAgB,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE;oBAC5D,SAAS,EAAE,CAAC;oBACZ,OAAO,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;gBAC1F,CAAC,CAAC,CAAC;gBAEH,MAAM,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;gBACpC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC3B,CAAC;QACH,CAAC;QAED,aAAa,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAAO;QAClB,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;IACjD,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,iBAA2B,EAAE;QACjD,MAAM,kBAAkB,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;QAEjF,OAAO,CAAC,KAAK,EAAE,CAAC;QAChB,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;QAE7B,cAAc;QACd,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;QAEjB,sBAAsB;QACtB,MAAM,WAAW,GAAG,IAAI,GAAG,EAA0B,CAAC;QACtD,MAAM,YAAY,GAAG,GAAG,CAAC,CAAC,iBAAiB;QAE3C,MAAM,mBAAmB,GAAG,KAAK,IAAI,EAAE;YACrC,OAAO,CAAC,KAAK,EAAE,CAAC;YAChB,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;YACpD,WAAW,CAAC,KAAK,EAAE,CAAC;YAEpB,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;YACzC,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACjC,CAAC,CAAC;QAEF,8CAA8C;QAC9C,MAAM,kBAAkB,CAAC,KAAK,EAAE,CAAC;QAEjC,kCAAkC;QAClC,MAAM,gBAAgB,GAAG,MAAM,kBAAkB,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAC7E,MAAM,aAAa,GAAG,MAAM,kBAAkB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACvE,MAAM,gBAAgB,GAAG,MAAM,kBAAkB,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAE7E,MAAM,gBAAgB,GAAG,CAAC,WAAmB,EAAE,EAAE;YAC/C,uCAAuC;YACvC,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;gBAClE,OAAO;YACT,CAAC;YAED,8CAA8C;YAC9C,IAAI,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;gBACjC,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;YAC7C,CAAC;YAED,gCAAgC;YAChC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBAChC,IAAI,WAAW,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;oBAC3B,mBAAmB,EAAE,CAAC;gBACxB,CAAC;YACH,CAAC,EAAE,YAAY,CAAC,CAAC;YAEjB,WAAW,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QACxC,CAAC,CAAC;QAEF,mCAAmC;QACnC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC;QAC/D,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC;QAC5D,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC;QAE/D,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAE/B,mCAAmC;QACnC,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;YAC9B,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;YAC5B,MAAM,kBAAkB,CAAC,IAAI,EAAE,CAAC;YAChC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,2BAA2B;QAC3B,MAAM,IAAI,OAAO,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC,CAAC,8BAA8B;IAC7D,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,WAAmB,EAAE,SAAiB,EAAE,UAAkB,EAAE,aAA4B;QACxH,sDAAsD;QACtD,IAAI,IAAI,CAAC,aAAa,KAAK,IAAI,IAAI,SAAS,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YAClE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,uBAAuB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;YAC9G,aAAa,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;YAC1C,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,SAAS,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YAC5D,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,qBAAqB,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;YACzG,aAAa,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;YAC1C,OAAO;QACT,CAAC;QAED,2BAA2B;QAC3B,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC;IAC9E,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,WAAmB,EAAE,SAAiB,EAAE,UAAkB,EAAE,aAA4B;QAClH,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QAEpD,sCAAsC;QACtC,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC/B,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC;QACrF,CAAC;QAED,gFAAgF;QAChF,MAAM,MAAM,GAAG,iBAAiB,CAAC,QAAQ,EAAE,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC,CAAC;QAE5E,6CAA6C;QAC7C,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE,IAAI,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YACzD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,WAAW,qBAAqB,CAAC,CAAC;YACpE,OAAO;QACT,CAAC;QAED,6CAA6C;QAC7C,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;YACpB,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACjB,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,yBAAyB,EAAE,QAAQ,CAAC,CAAC,CAAC;YACtD,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,YAAY,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC;YACnD,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,qEAAqE,EAAE,QAAQ,CAAC,CAAC,CAAC;YAClG,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,iBAAiB,QAAQ,CAAC,OAAO,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,iBAAiB,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC;YAC/H,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,kCAAkC,EAAE,MAAM,CAAC,CAAC,CAAC;YAC7D,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACnB,CAAC;QAED,0CAA0C;QAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE9E,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,WAAW,kCAAkC,CAAC,CAAC;YACjF,OAAO;QACT,CAAC;QAED,sEAAsE;QACtE,IAAI,UAAU,GAAG,MAAM,uBAAuB,CAAC,WAAW,CAAC,CAAC;QAE5D,yCAAyC;QACzC,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAClD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACzD,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,CAAC;QAC7E,IAAI,cAAc,EAAE,CAAC;YACnB,MAAM,cAAc,GAAG,MAAM,uBAAuB,CAAC,QAAQ,CAAC,CAAC;YAC/D,UAAU,GAAG,eAAe,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;QAC3D,CAAC;QAED,iCAAiC;QACjC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,sCAAsC;YACtC,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YAE5B,sCAAsC;YACtC,IAAI,IAAI,CAAC,aAAa,EAAE,cAAc,EAAE,CAAC;gBACvC,MAAM,OAAO,GAAG,MAAM,eAAe,CACnC,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,aAAa,CAAC,cAAc,EACjC,yBAAyB,QAAQ,GAAG,EACpC,IAAI,CAAC,MAAM,EACX,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,EAAE,CACzD,CAAC;gBACF,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,MAAM,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,UAAU,EACrF,aAAa,EAAE,8BAA8B,CAAC,CAAC;oBACjD,OAAO;gBACT,CAAC;YACH,CAAC;YAED,MAAM,OAAO,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC3G,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;QAC7F,CAAC;aAAM,CAAC;YACN,mCAAmC;YACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACzC,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC5B,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;gBAElE,iEAAiE;gBACjE,IAAI,IAAI,CAAC,aAAa,EAAE,cAAc,EAAE,CAAC;oBACvC,MAAM,OAAO,GAAG,MAAM,eAAe,CACnC,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,aAAa,CAAC,cAAc,EACjC,yBAAyB,QAAQ,OAAO,OAAO,CAAC,WAAW,GAAG,EAC9D,IAAI,CAAC,MAAM,EACX,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,EAAE,CACzD,CAAC;oBACF,IAAI,CAAC,OAAO,EAAE,CAAC;wBACb,MAAM,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,UAAU,EACrF,aAAa,EAAE,8BAA8B,CAAC,CAAC;wBACjD,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;wBACzB,SAAS;oBACX,CAAC;gBACH,CAAC;gBAED,MAAM,OAAO,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,0BAA0B,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;gBAC3G,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;gBAC3F,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC3B,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAAC,OAAe,EAAE,UAAkB,EAAE,QAAgB,EACtF,QAAgB,EAAE,aAA4B,EAAE,QAAiB;QACjE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,oBAAoB,EAAE,CAAC;QAClD,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC9D,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,GAAG,OAAO,IAAI,UAAU,EAAE,EAAE,MAAM,CAAC,CAAC;QACjE,MAAM,CAAC,oBAAoB,CAAC,QAAQ,YAAY,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC7F,MAAM,MAAM,CAAC,mBAAmB,EAAE,CAAC;QACnC,aAAa,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IAEO,KAAK,CAAC,UAAU,CAAC,UAA0B,EAAE,OAAe,EAAE,QAAgB,EACpF,QAAgB,EAAE,aAA4B,EAAE,UAA2B;QAC3E,IAAI,CAAC;YACH,aAAa,CAAC,YAAY,CAAC,MAAM,UAAU,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;QAC5F,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,EACjF,aAAa,EAAE,QAAQ,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,aAAa,CACzB,WAAmB,EACnB,SAAiB,EACjB,UAAkB,EAClB,aAA4B;QAE5B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,MAAM,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAC1E,aAAa,EAAE,iCAAiC,CAAC,CAAC;YACpD,OAAO;QACT,CAAC;QAED,sCAAsC;QACtC,IAAI,IAAI,CAAC,aAAa,EAAE,cAAc,EAAE,CAAC;YACvC,MAAM,OAAO,GAAG,MAAM,eAAe,CACnC,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,aAAa,CAAC,cAAc,EACjC,yBAAyB,WAAW,aAAa,EACjD,IAAI,CAAC,MAAM,EACX,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,CACvD,CAAC;YACF,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAC1E,aAAa,EAAE,8BAA8B,CAAC,CAAC;gBACjD,OAAO;YACT,CAAC;QACH,CAAC;QAED,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;YACnF,aAAa,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QACxC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAC1E,aAAa,EAAE,KAAK,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,oBAAoB;QAChC,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACvD,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;QACxE,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAChE,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QAElE,IAAI,CAAC;YACH,oDAAoD;YACpD,IAAI,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;gBAC/E,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YAC9D,CAAC;YACD,IAAI,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;gBACjF,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YAC/D,CAAC;YAED,8DAA8D;YAC9D,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;YACvF,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAEpF,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC1B,OAAO;YACT,CAAC;YAED,mCAAmC;YACnC,MAAM,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC;YAE1E,2CAA2C;YAC3C,KAAK,MAAM,QAAQ,IAAI,QAAQ,EAAE,CAAC;gBAChC,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBACvD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;gBAE1D,IAAI,CAAC;oBACH,gDAAgD;oBAChD,MAAM,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;oBAC9D,MAAM,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,CAAC;gBAC1D,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,6CAA6C;gBAC/C,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,2CAA2C;YAC3C,OAAO;QACT,CAAC;IACH,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tstest.classes.tstest.js","sourceRoot":"","sources":["../ts/tstest.classes.tstest.ts"],"names":[],"mappings":"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"}

package/dist_ts/tstest.interfaces.config.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Project configuration for tstest, read from the `@git.zone/tstest` section
+ * of `.smartconfig.json` - the same mechanism tsbundle, tswatch, tsrust and
+ * tsdocker already use.
+ */
+/**
+ * The artifact groups tstest writes to disk. Each maps to a fixed path under
+ * `.nogit/`; see `artifactPaths` in tstest.classes.artifacts.ts.
+ */
+export type TTstestArtifact = 'logs' | 'cache' | 'testfiles' | 'snapshots';
+export interface ITstestPrepareConfig {
+    /**
+     * Command run once, before the whole test run. Takes precedence over the
+     * `test:before` / `test:before:once` package.json scripts.
+     */
+    once?: string;
+    /**
+     * Command run before every individual test file. Takes precedence over the
+     * `test:before:testfile` package.json script.
+     */
+    perTestfile?: string;
+}
+export interface ITstestCleanupConfig {
+    /**
+     * Remove test artifacts as part of `gitzone release`. Defaults to true, so
+     * a release never ships with stale test output left on disk. Set false to
+     * opt a project out.
+     */
+    onRelease?: boolean;
+    /**
+     * Also remove artifacts after every local test run. Defaults to false,
+     * because the logs are usually the reason someone ran the tests.
+     */
+    afterRun?: boolean;
+    /**
+     * Artifact groups to remove. Defaults to logs, cache and testfiles.
+     * `snapshots` is deliberately not a default: snapshots are assertion
+     * baselines, and deleting them makes `matchSnapshot` silently re-record
+     * rather than compare.
+     */
+    artifacts?: TTstestArtifact[];
+    /**
+     * Additional project-specific paths to remove, relative to the project
+     * root. Absolute paths and paths escaping the project root are rejected.
+     */
+    additionalPaths?: string[];
+}
+export interface ITstestConfig {
+    prepare?: ITstestPrepareConfig;
+    cleanup?: ITstestCleanupConfig;
+}

package/dist_ts/tstest.interfaces.config.js

@@ -0,0 +1,7 @@
+/**
+ * Project configuration for tstest, read from the `@git.zone/tstest` section
+ * of `.smartconfig.json` - the same mechanism tsbundle, tswatch, tsrust and
+ * tsdocker already use.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN0ZXN0LmludGVyZmFjZXMuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvdHN0ZXN0LmludGVyZmFjZXMuY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUcifQ==

package/dist_ts/tstest.plugins.d.ts

@@ -4,6 +4,7 @@ import * as url from 'node:url';
 export { fs, path, url };
 import * as consolecolor from '@push.rocks/consolecolor';
 import * as smartbrowser from '@push.rocks/smartbrowser';
+import * as smartconfig from '@push.rocks/smartconfig';
 import * as smartserve from '@push.rocks/smartserve';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartfile from '@push.rocks/smartfile';
@@ -15,7 +16,7 @@ import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartshell from '@push.rocks/smartshell';
 import * as smartwatch from '@push.rocks/smartwatch';
 import * as tapbundle from '../dist_ts_tapbundle/index.js';
-export { consolecolor, smartbrowser, smartserve, smartdelay, smartfile, smartfs, smartfsInstance, smartlog, smartnetwork, smartpromise, smartshell, smartwatch, tapbundle, };
+export { consolecolor, smartbrowser, smartconfig, smartserve, smartdelay, smartfile, smartfs, smartfsInstance, smartlog, smartnetwork, smartpromise, smartshell, smartwatch, tapbundle, };
 import * as tsbundle from '@git.zone/tsbundle';
 import * as tsrun from '@git.zone/tsrun';
 export { tsbundle, tsrun };

package/dist_ts/tstest.plugins.js

@@ -6,6 +6,7 @@ export { fs, path, url };
 // @push.rocks scope
 import * as consolecolor from '@push.rocks/consolecolor';
 import * as smartbrowser from '@push.rocks/smartbrowser';
+import * as smartconfig from '@push.rocks/smartconfig';
 import * as smartserve from '@push.rocks/smartserve';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartfile from '@push.rocks/smartfile';
@@ -17,7 +18,7 @@ import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartshell from '@push.rocks/smartshell';
 import * as smartwatch from '@push.rocks/smartwatch';
 import * as tapbundle from '../dist_ts_tapbundle/index.js';
-export { consolecolor, smartbrowser, smartserve, smartdelay, smartfile, smartfs, smartfsInstance, smartlog, smartnetwork, smartpromise, smartshell, smartwatch, tapbundle, };
+export { consolecolor, smartbrowser, smartconfig, smartserve, smartdelay, smartfile, smartfs, smartfsInstance, smartlog, smartnetwork, smartpromise, smartshell, smartwatch, tapbundle, };
 // @git.zone scope
 import * as tsbundle from '@git.zone/tsbundle';
 import * as tsrun from '@git.zone/tsrun';
@@ -28,4 +29,4 @@ export { figures };
 // third party
 import * as ws from 'ws';
 export { ws };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN0ZXN0LnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90c3Rlc3QucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFFaEMsT0FBTyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFekIsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBQy9DLE1BQU0sZUFBZSxHQUFHLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRSxDQUFDLENBQUM7QUFDL0UsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxTQUFTLE1BQU0sK0JBQStCLENBQUM7QUFFM0QsT0FBTyxFQUNMLFlBQVksRUFDWixZQUFZLEVBQ1osVUFBVSxFQUNWLFVBQVUsRUFDVixTQUFTLEVBQ1QsT0FBTyxFQUNQLGVBQWUsRUFDZixRQUFRLEVBQ1IsWUFBWSxFQUNaLFlBQVksRUFDWixVQUFVLEVBQ1YsVUFBVSxFQUNWLFNBQVMsR0FDVixDQUFDO0FBRUYsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxRQUFRLE1BQU0sb0JBQW9CLENBQUM7QUFDL0MsT0FBTyxLQUFLLEtBQUssTUFBTSxpQkFBaUIsQ0FBQztBQUV6QyxPQUFPLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxDQUFDO0FBRTNCLGVBQWU7QUFDZixPQUFPLE9BQU8sTUFBTSxTQUFTLENBQUM7QUFFOUIsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBRW5CLGNBQWM7QUFDZCxPQUFPLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQztBQUV6QixPQUFPLEVBQ0wsRUFBRSxFQUNILENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN0ZXN0LnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90c3Rlc3QucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFFaEMsT0FBTyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFekIsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsTUFBTSxlQUFlLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksT0FBTyxDQUFDLG1CQUFtQixFQUFFLENBQUMsQ0FBQztBQUMvRSxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFNBQVMsTUFBTSwrQkFBK0IsQ0FBQztBQUUzRCxPQUFPLEVBQ0wsWUFBWSxFQUNaLFlBQVksRUFDWixXQUFXLEVBQ1gsVUFBVSxFQUNWLFVBQVUsRUFDVixTQUFTLEVBQ1QsT0FBTyxFQUNQLGVBQWUsRUFDZixRQUFRLEVBQ1IsWUFBWSxFQUNaLFlBQVksRUFDWixVQUFVLEVBQ1YsVUFBVSxFQUNWLFNBQVMsR0FDVixDQUFDO0FBRUYsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxRQUFRLE1BQU0sb0JBQW9CLENBQUM7QUFDL0MsT0FBTyxLQUFLLEtBQUssTUFBTSxpQkFBaUIsQ0FBQztBQUV6QyxPQUFPLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxDQUFDO0FBRTNCLGVBQWU7QUFDZixPQUFPLE9BQU8sTUFBTSxTQUFTLENBQUM7QUFFOUIsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBRW5CLGNBQWM7QUFDZCxPQUFPLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQztBQUV6QixPQUFPLEVBQ0wsRUFBRSxFQUNILENBQUEifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tstest",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "private": false,
   "description": "A powerful, modern test runner for TypeScript with multi-runtime support (Node.js, Deno, Bun, Chromium) and a batteries-included test framework.",
   "exports": {
@@ -16,16 +16,18 @@
     "tstest": "./cli.js"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.4.2",
-    "@types/node": "26.4.1",
+    "@git.zone/tsbuild": "^4.4.3",
+    "@types/node": "26.5.0",
     "tsx": "^4.23.13"
   },
   "dependencies": {
     "@git.zone/tsbundle": "^2.13.0",
     "@git.zone/tsrun": "^2.0.6",
+    "@lossless.org/objectstorage": "10.0.1",
     "@push.rocks/consolecolor": "^2.0.4",
     "@push.rocks/qenv": "^6.1.4",
     "@push.rocks/smartbrowser": "^2.0.11",
+    "@push.rocks/smartconfig": "^6.2.0",
     "@push.rocks/smartcrypto": "^2.0.4",
     "@push.rocks/smartdelay": "^3.1.0",
     "@push.rocks/smartenv": "^6.1.0",
@@ -45,8 +47,7 @@
     "@push.rocks/smartwatch": "^6.4.0",
     "@types/ws": "^8.18.1",
     "figures": "^6.1.0",
-    "ws": "^8.20.0",
-    "@lossless.org/objectstorage": "10.0.1"
+    "ws": "^8.20.0"
   },
   "files": [
     "ts/**/*",
@@ -64,7 +65,9 @@
     "last 1 chrome versions"
   ],
   "scripts": {
-    "test": "pnpm run build && pnpm run test:tapbundle:verbose && pnpm run test:tstest:verbose",
+    "test": "pnpm run build && pnpm run test:root:verbose && pnpm run test:tapbundle:verbose && pnpm run test:tstest:verbose",
+    "test:root": "tsx ./cli.child.ts \"test/test.*.ts\"",
+    "test:root:verbose": "tsx ./cli.child.ts \"test/test.*.ts\" --verbose",
     "test:tapbundle": "tsx ./cli.child.ts \"test/tapbundle/**/*.ts\"",
     "test:tapbundle:verbose": "tsx ./cli.child.ts \"test/tapbundle/**/*.ts\" --verbose",
     "test:tstest": "tsx ./cli.child.ts \"test/tstest/**/*.ts\"",

package/readme.md

@@ -160,6 +160,74 @@ tstest migrate --write
 | `--watch`, `-w` | Re-run tests on file changes |
 | `--watch-ignore <patterns>` | Ignore patterns in watch mode |
 
+| Command | Description |
+|---|---|
+| `tstest clean` | Remove the artifacts tstest wrote |
+| `tstest clean --dry-run` | List what would be removed, remove nothing |
+
+## Project Configuration
+
+tstest reads the `@git.zone/tstest` section of `.smartconfig.json`, the same
+mechanism tsbundle, tswatch, tsrust and tsdocker use.
+
+```json
+{
+  "@git.zone/tstest": {
+    "prepare": {
+      "once": "docker compose up -d",
+      "perTestfile": "node scripts/reset-fixtures.mjs"
+    },
+    "cleanup": {
+      "onRelease": true,
+      "afterRun": false,
+      "artifacts": ["logs", "cache", "testfiles"],
+      "additionalPaths": [".nogit/my-project-fixtures"]
+    }
+  }
+}
+```
+
+### prepare
+
+Replaces the `test:before`, `test:before:once` and `test:before:testfile`
+package.json scripts, which remain supported for projects that already use
+them. The config wins where both are present.
+
+| Key | Description |
+|---|---|
+| `once` | Runs once before the whole test run |
+| `perTestfile` | Runs before each individual test file |
+
+### cleanup
+
+Test runs leave data on disk, and on a long-lived machine it accumulates
+indefinitely. Cleanup removes it.
+
+| Key | Default | Description |
+|---|---|---|
+| `onRelease` | `true` | Clean as part of `gitzone release`. Set `false` to opt out. |
+| `afterRun` | `false` | Also clean after every local test run |
+| `artifacts` | `["logs", "cache", "testfiles"]` | Which artifact groups to remove |
+| `additionalPaths` | `[]` | Extra project-relative paths to remove |
+
+Artifact groups map to fixed locations:
+
+| Group | Path | Notes |
+|---|---|---|
+| `logs` | `.nogit/testlogs/` | Written by `--logfile` |
+| `cache` | `.nogit/tstest_cache/` | Browser bundle cache |
+| `testfiles` | `.nogit/testfiles/` | Fixtures downloaded by tapnodetools |
+| `snapshots` | `.nogit/test_snapshots/` | **Not cleaned by default** |
+
+`snapshots` is excluded from the defaults deliberately. Snapshots are
+assertion baselines, not output: deleting one makes the next `matchSnapshot`
+re-record it instead of comparing, so the assertion silently passes. Only
+list `snapshots` when you actually intend to discard those baselines.
+
+`additionalPaths` entries must be relative and stay inside the project.
+Absolute paths, and paths that escape the project root, are refused and
+reported rather than followed.
+
 ## Writing Tests with tapbundle
 
 ### Basic Syntax

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tstest',
-  version: '6.0.0',
+  version: '6.1.0',
   description: 'A powerful, modern test runner for TypeScript with multi-runtime support (Node.js, Deno, Bun, Chromium) and a batteries-included test framework.'
 }

package/ts/index.ts

@@ -1,5 +1,25 @@
 import { TsTest } from './tstest.classes.tstest.js';
 import type { LogOptions } from './tstest.logging.js';
+import { loadTstestConfig } from './tstest.classes.config.js';
+import {
+  cleanArtifacts,
+  formatBytes,
+  resolveCleanupTargets,
+} from './tstest.classes.artifacts.js';
+
+export * from './tstest.interfaces.config.js';
+export {
+  artifactPaths,
+  cleanArtifacts,
+  defaultCleanupArtifacts,
+  formatBytes,
+  resolveCleanupTargets,
+} from './tstest.classes.artifacts.js';
+export {
+  cleanupRunsAfterTests,
+  cleanupRunsOnRelease,
+  loadTstestConfig,
+} from './tstest.classes.config.js';
 
 export enum TestExecutionMode {
   DIRECTORY = 'directory',
@@ -44,6 +64,33 @@ export const runCli = async () => {
   
   // Parse command line arguments
   const args = process.argv.slice(2);
+
+  // `tstest clean` removes the artifacts tstest wrote, per .smartconfig.json.
+  if (args[0] === 'clean') {
+    const dryRun = args.includes('--dry-run');
+    const cwd = process.cwd();
+    const config = loadTstestConfig(cwd);
+
+    if (dryRun) {
+      const { targets } = resolveCleanupTargets(cwd, config.cleanup);
+      console.log('tstest clean (dry run) would remove:');
+      for (const target of targets) {
+        console.log(`  ${target}`);
+      }
+      return;
+    }
+
+    const result = cleanArtifacts(cwd, config);
+    if (result.removed.length === 0) {
+      console.log('tstest clean: nothing to remove');
+      return;
+    }
+    for (const entry of result.removed) {
+      console.log(`  removed ${entry.path} (${formatBytes(entry.bytes)})`);
+    }
+    console.log(`tstest clean: reclaimed ${formatBytes(result.totalBytes)}`);
+    return;
+  }
   const logOptions: LogOptions = {};
   let testPath: string | null = null;
   let tags: string[] = [];
@@ -160,6 +207,7 @@ export const runCli = async () => {
   if (!testPath) {
     console.error('You must specify a test directory/file/pattern as argument. Please try again.');
     console.error('\nUsage: tstest <path> [options]');
+    console.error('       tstest clean [--dry-run]');
     console.error('\nOptions:');
     console.error('  --version         Show version information');
     console.error('  --quiet, -q       Minimal output');
@@ -173,6 +221,9 @@ export const runCli = async () => {
     console.error('  --timeout <s>     Timeout test files after s seconds');
     console.error('  --watch, -w       Watch for file changes and re-run tests');
     console.error('  --watch-ignore    Patterns to ignore in watch mode (comma-separated)');
+    console.error('\nCleanup:');
+    console.error('  clean             Remove test artifacts (.nogit/testlogs, tstest_cache, testfiles)');
+    console.error('  clean --dry-run   Show what would be removed without removing it');
     process.exit(1);
   }
   

package/ts/tstest.classes.artifacts.ts

@@ -0,0 +1,173 @@
+import * as plugins from './tstest.plugins.js';
+import type {
+  ITstestCleanupConfig,
+  ITstestConfig,
+  TTstestArtifact,
+} from './tstest.interfaces.config.js';
+
+/**
+ * Every location tstest writes to, keyed by artifact group. Keeping this in
+ * one place is what makes cleanup complete: a new write location must be
+ * registered here, not scattered through the runtimes.
+ */
+export const artifactPaths: Record<TTstestArtifact, string> = {
+  logs: plugins.path.join('.nogit', 'testlogs'),
+  cache: plugins.path.join('.nogit', 'tstest_cache'),
+  testfiles: plugins.path.join('.nogit', 'testfiles'),
+  snapshots: plugins.path.join('.nogit', 'test_snapshots'),
+};
+
+/**
+ * Removed unless a project opts in. Snapshots are excluded because they are
+ * assertion baselines rather than output - see ITstestCleanupConfig.artifacts.
+ */
+export const defaultCleanupArtifacts: TTstestArtifact[] = ['logs', 'cache', 'testfiles'];
+
+export interface IRemovedArtifact {
+  path: string;
+  bytes: number;
+}
+
+export interface ICleanupResult {
+  removed: IRemovedArtifact[];
+  totalBytes: number;
+}
+
+/** Human-readable byte size, so cleanup output states what it reclaimed. */
+export const formatBytes = (bytes: number): string => {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ['KB', 'MB', 'GB', 'TB'];
+  let value = bytes / 1024;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  // One decimal below 10 keeps small differences visible; above that the
+  // fraction is noise.
+  return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unitIndex]}`;
+};
+
+const directorySize = (absolutePath: string): number => {
+  let total = 0;
+  const walk = (current: string) => {
+    let entries: string[];
+    try {
+      entries = plugins.fs.readdirSync(current);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryPath = plugins.path.join(current, entry);
+      let stat: import('fs').Stats;
+      try {
+        stat = plugins.fs.lstatSync(entryPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walk(entryPath);
+      } else {
+        total += stat.size;
+      }
+    }
+  };
+  try {
+    const stat = plugins.fs.lstatSync(absolutePath);
+    if (stat.isDirectory()) {
+      walk(absolutePath);
+    } else {
+      total = stat.size;
+    }
+  } catch {
+    return 0;
+  }
+  return total;
+};
+
+/**
+ * Resolve a configured relative path against the project root, refusing
+ * anything that escapes it. Cleanup deletes recursively, so an unchecked
+ * `../..` here would be destructive.
+ */
+const resolveInsideProject = (cwd: string, candidate: string): string | null => {
+  if (plugins.path.isAbsolute(candidate)) {
+    return null;
+  }
+  const resolvedRoot = plugins.path.resolve(cwd);
+  const resolved = plugins.path.resolve(resolvedRoot, candidate);
+  if (resolved === resolvedRoot) {
+    return null;
+  }
+  const withSeparator = resolvedRoot.endsWith(plugins.path.sep)
+    ? resolvedRoot
+    : `${resolvedRoot}${plugins.path.sep}`;
+  return resolved.startsWith(withSeparator) ? resolved : null;
+};
+
+/** The concrete paths a cleanup would remove, after validation. */
+export const resolveCleanupTargets = (
+  cwd: string,
+  cleanupConfig: ITstestCleanupConfig = {},
+): { targets: string[]; rejected: string[] } => {
+  const artifacts = cleanupConfig.artifacts ?? defaultCleanupArtifacts;
+  const targets: string[] = [];
+  const rejected: string[] = [];
+
+  for (const artifact of artifacts) {
+    const relativePath = artifactPaths[artifact];
+    if (!relativePath) {
+      rejected.push(String(artifact));
+      continue;
+    }
+    targets.push(plugins.path.resolve(cwd, relativePath));
+  }
+
+  for (const additional of cleanupConfig.additionalPaths ?? []) {
+    const resolved = resolveInsideProject(cwd, additional);
+    if (!resolved) {
+      rejected.push(additional);
+      continue;
+    }
+    targets.push(resolved);
+  }
+
+  return { targets, rejected };
+};
+
+/**
+ * Remove the configured artifacts. Missing paths are not an error - cleanup
+ * is expected to run on projects that never produced some of them.
+ */
+export const cleanArtifacts = (
+  cwd: string,
+  config: ITstestConfig = {},
+): ICleanupResult => {
+  const { targets, rejected } = resolveCleanupTargets(cwd, config.cleanup);
+
+  for (const badPath of rejected) {
+    console.error(
+      `tstest cleanup: refusing "${badPath}" - additionalPaths must be relative and stay inside the project`,
+    );
+  }
+
+  const removed: IRemovedArtifact[] = [];
+  let totalBytes = 0;
+
+  for (const target of targets) {
+    if (!plugins.fs.existsSync(target)) {
+      continue;
+    }
+    const bytes = directorySize(target);
+    try {
+      plugins.fs.rmSync(target, { recursive: true, force: true });
+    } catch (error) {
+      console.error(`tstest cleanup: could not remove ${target}: ${error}`);
+      continue;
+    }
+    removed.push({ path: plugins.path.relative(cwd, target) || target, bytes });
+    totalBytes += bytes;
+  }
+
+  return { removed, totalBytes };
+};

package/ts/tstest.classes.beforescripts.ts

@@ -1,6 +1,7 @@
 import * as plugins from './tstest.plugins.js';
 import type { TsTestLogger } from './tstest.logging.js';
 import type { Smartshell } from '@push.rocks/smartshell';
+import { loadTstestConfig } from './tstest.classes.config.js';
 
 export interface IBeforeScripts {
   /** The "test:before" or "test:before:once" script command, or null if not defined */
@@ -10,11 +11,20 @@ export interface IBeforeScripts {
 }
 
 /**
- * Load before-script commands from the project's package.json scripts section.
+ * Load before-script commands. `.smartconfig.json`'s `@git.zone/tstest`
+ * prepare block wins; the package.json `test:before*` scripts remain
+ * supported so existing projects keep working.
  */
 export function loadBeforeScripts(cwd: string): IBeforeScripts {
   const result: IBeforeScripts = { beforeOnce: null, beforeTestfile: null };
 
+  const prepareConfig = loadTstestConfig(cwd).prepare;
+  if (prepareConfig?.once) result.beforeOnce = prepareConfig.once;
+  if (prepareConfig?.perTestfile) result.beforeTestfile = prepareConfig.perTestfile;
+  if (result.beforeOnce && result.beforeTestfile) {
+    return result;
+  }
+
   try {
     const packageJsonPath = plugins.path.join(cwd, 'package.json');
     const packageJson = JSON.parse(plugins.fs.readFileSync(packageJsonPath, 'utf8'));
@@ -22,7 +32,9 @@ export function loadBeforeScripts(cwd: string): IBeforeScripts {
     if (!scripts) return result;
 
     // test:before takes precedence over test:before:once (they are aliases)
-    if (scripts['test:before']) {
+    if (result.beforeOnce) {
+      // already provided by .smartconfig.json
+    } else if (scripts['test:before']) {
       result.beforeOnce = scripts['test:before'];
       if (scripts['test:before:once']) {
         console.warn('Warning: Both "test:before" and "test:before:once" are defined. Using "test:before".');
@@ -31,7 +43,7 @@ export function loadBeforeScripts(cwd: string): IBeforeScripts {
       result.beforeOnce = scripts['test:before:once'];
     }
 
-    if (scripts['test:before:testfile']) {
+    if (!result.beforeTestfile && scripts['test:before:testfile']) {
       result.beforeTestfile = scripts['test:before:testfile'];
     }
   } catch {

package/ts/tstest.classes.config.ts

@@ -0,0 +1,25 @@
+import * as plugins from './tstest.plugins.js';
+import type { ITstestConfig } from './tstest.interfaces.config.js';
+
+/**
+ * Read the `@git.zone/tstest` section of `.smartconfig.json`, following the
+ * same convention as tsbundle, tswatch, tsrust and tsdocker. A project
+ * without the section gets the defaults, so this is safe to call anywhere.
+ */
+export const loadTstestConfig = (cwd: string): ITstestConfig => {
+  try {
+    const smartconfigInstance = new plugins.smartconfig.Smartconfig(cwd);
+    return smartconfigInstance.dataFor<ITstestConfig>('@git.zone/tstest', {});
+  } catch (error) {
+    console.error(`tstest: could not read .smartconfig.json (${error}); using defaults`);
+    return {};
+  }
+};
+
+/** Cleanup runs on release unless the project opts out. */
+export const cleanupRunsOnRelease = (config: ITstestConfig): boolean =>
+  config.cleanup?.onRelease !== false;
+
+/** Cleanup after a local test run is opt-in. */
+export const cleanupRunsAfterTests = (config: ITstestConfig): boolean =>
+  config.cleanup?.afterRun === true;

package/ts/tstest.classes.tstest.ts

@@ -29,6 +29,8 @@ import {
 
 // Before-script support
 import { loadBeforeScripts, runBeforeScript, type IBeforeScripts } from './tstest.classes.beforescripts.js';
+import { cleanupRunsAfterTests, loadTstestConfig } from './tstest.classes.config.js';
+import { cleanArtifacts, formatBytes } from './tstest.classes.artifacts.js';
 
 export class TsTest {
   public testDir: TestDirectory;
@@ -164,6 +166,16 @@ export class TsTest {
    */
   public async cleanup() {
     this.smartshellInstance.smartexit.deregister();
+
+    // Opt-in: projects that do not want their test output kept can have it
+    // removed as soon as the run finishes.
+    const config = loadTstestConfig(this.testDir.cwd);
+    if (cleanupRunsAfterTests(config)) {
+      const result = cleanArtifacts(this.testDir.cwd, config);
+      if (result.totalBytes > 0) {
+        console.log(`tstest: cleaned test artifacts, reclaimed ${formatBytes(result.totalBytes)}`);
+      }
+    }
   }
 
   public async runWatch(ignorePatterns: string[] = []) {

package/ts/tstest.interfaces.config.ts

@@ -0,0 +1,55 @@
+/**
+ * Project configuration for tstest, read from the `@git.zone/tstest` section
+ * of `.smartconfig.json` - the same mechanism tsbundle, tswatch, tsrust and
+ * tsdocker already use.
+ */
+
+/**
+ * The artifact groups tstest writes to disk. Each maps to a fixed path under
+ * `.nogit/`; see `artifactPaths` in tstest.classes.artifacts.ts.
+ */
+export type TTstestArtifact = 'logs' | 'cache' | 'testfiles' | 'snapshots';
+
+export interface ITstestPrepareConfig {
+  /**
+   * Command run once, before the whole test run. Takes precedence over the
+   * `test:before` / `test:before:once` package.json scripts.
+   */
+  once?: string;
+  /**
+   * Command run before every individual test file. Takes precedence over the
+   * `test:before:testfile` package.json script.
+   */
+  perTestfile?: string;
+}
+
+export interface ITstestCleanupConfig {
+  /**
+   * Remove test artifacts as part of `gitzone release`. Defaults to true, so
+   * a release never ships with stale test output left on disk. Set false to
+   * opt a project out.
+   */
+  onRelease?: boolean;
+  /**
+   * Also remove artifacts after every local test run. Defaults to false,
+   * because the logs are usually the reason someone ran the tests.
+   */
+  afterRun?: boolean;
+  /**
+   * Artifact groups to remove. Defaults to logs, cache and testfiles.
+   * `snapshots` is deliberately not a default: snapshots are assertion
+   * baselines, and deleting them makes `matchSnapshot` silently re-record
+   * rather than compare.
+   */
+  artifacts?: TTstestArtifact[];
+  /**
+   * Additional project-specific paths to remove, relative to the project
+   * root. Absolute paths and paths escaping the project root are rejected.
+   */
+  additionalPaths?: string[];
+}
+
+export interface ITstestConfig {
+  prepare?: ITstestPrepareConfig;
+  cleanup?: ITstestCleanupConfig;
+}

package/ts/tstest.plugins.ts

@@ -8,6 +8,7 @@ export { fs, path, url };
 // @push.rocks scope
 import * as consolecolor from '@push.rocks/consolecolor';
 import * as smartbrowser from '@push.rocks/smartbrowser';
+import * as smartconfig from '@push.rocks/smartconfig';
 import * as smartserve from '@push.rocks/smartserve';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartfile from '@push.rocks/smartfile';
@@ -23,6 +24,7 @@ import * as tapbundle from '../dist_ts_tapbundle/index.js';
 export {
   consolecolor,
   smartbrowser,
+  smartconfig,
   smartserve,
   smartdelay,
   smartfile,