@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/commands/test-stale-gate.d.ts

@@ -1,52 +0,0 @@
-/**
- * Pre-dispatch gates for `fireforge test` that stand between the request
- * and a run against a stale or under-packaged runtime: the packaging
- * coverage refusal, the stale-content refusal, and the compiled
- * StaticComponents refusal. Split out of `test.ts` so the command module
- * stays wiring. The probes and refusal copy live in
- * `src/core/test-stale-check.ts`.
- */
-import type { BuildBaseline } from '../core/build-baseline-types.js';
-import type { TestOptions } from '../types/commands/index.js';
-/**
- * Stale-build preflight: when `--build` was not requested, detect packageable
- * engine edits since the last successful build and fail up front unless the
- * operator explicitly accepts the stale package risk.
- *
- * Packaging coverage is checked first, on every non-`--build` run and
- * regardless of staleness or `--allow-stale-build`: a runtime packaged by a
- * file-scoped `test --build` can lack support fixtures for other manifests
- * even when nothing changed since, and dispatching such a run hangs on missing
- * fixtures rather than failing, so the flag (which only accepts stale
- * content) must not be the trigger. A three-file scoped rebuild leaving one
- * fixture unpackaged makes a later run over different files time out waiting
- * on an event that never fires.
- *
- * Exception: a path-less `test --doctor` stops at the Marionette health check
- * (`runDoctorPreflight` returns 'stop' when no test paths were given) and
- * never dispatches a test, so it needs no packaging coverage. Treating it as
- * a full-suite request would refuse a probe that touches no fixtures. The
- * stale-content refusal still applies to it unchanged.
- */
-export declare function enforceStaleBuildGate(projectRoot: string, engineDir: string, options: TestOptions, normalizedPaths: readonly string[], 
-/**
- * `quiet`: refuse only, without the exemption note (the pre-lock pass).
- * `launchablePath`: the engine-relative binary the run launches, which
- * anchors the stale-compiled check (skipped without one).
- */
-gate?: {
-    quiet?: boolean;
-    launchablePath?: string | undefined;
-}): Promise<void>;
-/**
- * Compiled-StaticComponents gate: refuses runs whose child process would
- * resolve a stale compiled component table. `components.conf` entries bake
- * into compiled code that only a full build regenerates. A scoped
- * `test --build` repackages the file but the failure surfaces as
- * `NS_ERROR_MALFORMED_URI` inside the test. Applies to build-less runs
- * (after the coverage refusal) and to scoped `test --build` runs (before
- * the pre-test build, which cannot fix the table). A path-less
- * `test --build` is exempt: its full build refreshes the anchor itself.
- * `--allow-stale-components` downgrades the refusal to a warning.
- */
-export declare function enforceStaticComponentsGate(engineDir: string, baseline: BuildBaseline | undefined, options: TestOptions): Promise<void>;

package/dist/src/commands/test-stale-gate.js

@@ -1,165 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Pre-dispatch gates for `fireforge test` that stand between the request
- * and a run against a stale or under-packaged runtime: the packaging
- * coverage refusal, the stale-content refusal, and the compiled
- * StaticComponents refusal. Split out of `test.ts` so the command module
- * stays wiring. The probes and refusal copy live in
- * `src/core/test-stale-check.ts`.
- */
-import { filterByCarriedFullCoverage } from '../core/coverage-dispatch.js';
-import { checkStaleBuildForTest, checkStaticComponentsStale, findChangedTestManifestsForPaths, findCompiledSourcesNewerThanBinary, findUncoveredRequestPaths, formatStaleBuildWarning, formatStaleCompiledRefusal, formatStaticComponentsRefusal, formatTestCoverageRefusal, FULL_SUITE_REQUEST, } from '../core/test-stale-check.js';
-import { formatStaleExemptions } from '../core/test-stale-exempt.js';
-import { PreflightRefusalError } from '../errors/base.js';
-import { isProcessAlive } from '../utils/errors.js';
-import { info, warn } from '../utils/logger.js';
-import { describePerfStaleImpact } from './test-perf-scope.js';
-/**
- * Stale-build preflight: when `--build` was not requested, detect packageable
- * engine edits since the last successful build and fail up front unless the
- * operator explicitly accepts the stale package risk.
- *
- * Packaging coverage is checked first, on every non-`--build` run and
- * regardless of staleness or `--allow-stale-build`: a runtime packaged by a
- * file-scoped `test --build` can lack support fixtures for other manifests
- * even when nothing changed since, and dispatching such a run hangs on missing
- * fixtures rather than failing, so the flag (which only accepts stale
- * content) must not be the trigger. A three-file scoped rebuild leaving one
- * fixture unpackaged makes a later run over different files time out waiting
- * on an event that never fires.
- *
- * Exception: a path-less `test --doctor` stops at the Marionette health check
- * (`runDoctorPreflight` returns 'stop' when no test paths were given) and
- * never dispatches a test, so it needs no packaging coverage. Treating it as
- * a full-suite request would refuse a probe that touches no fixtures. The
- * stale-content refusal still applies to it unchanged.
- */
-export async function enforceStaleBuildGate(projectRoot, engineDir, options, normalizedPaths, 
-/**
- * `quiet`: refuse only, without the exemption note (the pre-lock pass).
- * `launchablePath`: the engine-relative binary the run launches, which
- * anchors the stale-compiled check (skipped without one).
- */
-gate = {}) {
-    const stale = await checkStaleBuildForTest(projectRoot, engineDir);
-    enforceControlBuiltGate(stale.baseline);
-    const dispatchesNoTests = options.doctor === true && normalizedPaths.length === 0;
-    if (!dispatchesNoTests) {
-        await enforceCoverageGate(engineDir, stale.baseline, normalizedPaths);
-    }
-    await enforceStaticComponentsGate(engineDir, stale.baseline, options);
-    await enforceStaleCompiledGate(engineDir, stale.baseline, options, gate.launchablePath);
-    const exempt = stale.exempt ?? [];
-    if (!stale.stale && exempt.length > 0 && gate.quiet !== true) {
-        info(`Stale-build preflight: ${exempt.length} edit(s) since the last build need no rebuild: ${formatStaleExemptions(exempt)}.`);
-    }
-    if (!stale.stale)
-        return;
-    // The one-line repackaging command, so a build-less sitting (a perf
-    // series) can repackage and continue without dispatching anything.
-    const repackage = normalizedPaths.length > 0
-        ? `fireforge test --build-only ${normalizedPaths.join(' ')}`
-        : 'fireforge build --ui';
-    const perfImpact = options.perfSamples === undefined
-        ? ''
-        : `\n\n${await describePerfStaleImpact(engineDir, stale.changedPaths, normalizedPaths)}`;
-    const staleMessage = `${formatStaleBuildWarning(stale)}\n\n` +
-        'Run `fireforge test --build` to refresh the packaged runtime first — that is almost ' +
-        'always the right move, because the usual cause is your own edit landing between the ' +
-        'last build and this run. To repackage without running anything: ' +
-        `\`${repackage}\`.${perfImpact}\n\n` +
-        '`--allow-stale-build` is NOT the general escape hatch: it accepts a packaging that ' +
-        'predates the edit under test, so the run tests the OLD code. Pass it only when you ' +
-        'rebuilt out-of-band (outside FireForge) and know the packaged runtime already contains ' +
-        'the change.';
-    if (options.allowStaleBuild === true) {
-        warn(staleMessage);
-    }
-    else {
-        throw new PreflightRefusalError(staleMessage, 'stale-build');
-    }
-}
-/**
- * Control-built refusal: the recorded build compiled a negative control
- * into the binary, and no build since has recompiled the restored source
- * (the run was killed, or its restore build failed). Every test against
- * that binary tests the mutation. Not bypassable: `--allow-stale-build`
- * accepts old content, not a deliberately broken binary.
- */
-function enforceControlBuiltGate(baseline) {
-    const stamp = baseline?.controlBuild;
-    if (stamp === undefined)
-        return;
-    throw new PreflightRefusalError(`The binary under test was built with the negative control ${stamp.diffFile} applied ` +
-        `(${stamp.targets.map((target) => `engine/${target}`).join(', ')}, applied ${stamp.appliedAt}), ` +
-        'and no build has recompiled the restored source since. Run "fireforge build" to ' +
-        'rebuild the binary without the control, then rerun.', 'control-built');
-}
-/**
- * Stale-compiled refusal: compiled sources modified after the binary under
- * test was linked. `--allow-stale-build` downgrades it to a warning, as it
- * does the stale-build refusal.
- */
-async function enforceStaleCompiledGate(engineDir, baseline, options, launchablePath) {
-    const result = await findCompiledSourcesNewerThanBinary(engineDir, baseline, launchablePath);
-    if (result === undefined || result.paths.length === 0)
-        return;
-    const message = formatStaleCompiledRefusal(result);
-    if (options.allowStaleBuild === true) {
-        warn(message);
-        return;
-    }
-    throw new PreflightRefusalError(message, 'stale-compiled');
-}
-/**
- * Packaging-coverage refusal. A path outside the recorded scoped list is
- * still covered while its own staging inputs are unchanged against a
- * carried full-build anchor. The refusal names, per uncovered path, the
- * inputs that changed.
- */
-async function enforceCoverageGate(engineDir, baseline, normalizedPaths) {
-    const recordedCoverage = baseline?.testPackagingCoverage;
-    const outsideList = findUncoveredRequestPaths(recordedCoverage, normalizedPaths);
-    if (outsideList.length === 0)
-        return;
-    const remaining = await filterByCarriedFullCoverage(engineDir, baseline, outsideList, FULL_SUITE_REQUEST);
-    if (remaining.length === 0)
-        return;
-    const uncovered = remaining.map((request) => request.path);
-    // The refusal is correct on its own. Naming the manifest that gained
-    // an entry is the triage step it otherwise leaves to the reader.
-    const changedManifests = await findChangedTestManifestsForPaths(engineDir, baseline, uncovered);
-    throw new PreflightRefusalError(formatTestCoverageRefusal(uncovered, Array.isArray(recordedCoverage) ? recordedCoverage : [], changedManifests, {
-        changedInputs: Object.fromEntries(remaining.map((request) => [request.path, request.changed])),
-        carriesFullAnchor: baseline?.fullCoverageAnchor !== undefined,
-        recordedBy: baseline?.recordedBy,
-        builtAt: baseline?.builtAt,
-        recorder: baseline?.recorder,
-        recorderAlive: baseline?.recorder !== undefined &&
-            baseline.recorder.pid !== process.pid &&
-            isProcessAlive(baseline.recorder.pid),
-    }), 'coverage-replaced');
-}
-/**
- * Compiled-StaticComponents gate: refuses runs whose child process would
- * resolve a stale compiled component table. `components.conf` entries bake
- * into compiled code that only a full build regenerates. A scoped
- * `test --build` repackages the file but the failure surfaces as
- * `NS_ERROR_MALFORMED_URI` inside the test. Applies to build-less runs
- * (after the coverage refusal) and to scoped `test --build` runs (before
- * the pre-test build, which cannot fix the table). A path-less
- * `test --build` is exempt: its full build refreshes the anchor itself.
- * `--allow-stale-components` downgrades the refusal to a warning.
- */
-export async function enforceStaticComponentsGate(engineDir, baseline, options) {
-    const result = await checkStaticComponentsStale(engineDir, baseline);
-    if (!result.stale) {
-        return;
-    }
-    const message = formatStaticComponentsRefusal(result.changedManifests);
-    if (options.allowStaleComponents === true) {
-        warn(message);
-        return;
-    }
-    throw new PreflightRefusalError(message, 'stale-components');
-}

package/dist/src/commands/test-verdict.d.ts

@@ -1,92 +0,0 @@
-import type { HarnessRunVerdict } from '../core/test-harness-crash.js';
-/**
- * Reason codes the emission layer can put on a `FIREFORGE-VERDICT: FAIL`
- * line. The first three mirror the harness classifier, as does
- * `server-startup`: a harness-crash-class infrastructure failure where a
- * mochitest server never came up, so no test ran. `preflight` covers
- * every failure before harness classification (missing/stale builds,
- * invalid paths, port conflicts, config errors, spawn failures),
- * `inconclusive` marks a run whose harness result exists but cannot be
- * trusted because `engine/` changed (or became unprobeable one-sidedly)
- * while the tests ran, `lock-timeout` marks a run that never started
- * because the engine session lock stayed contended past the wait budget,
- * and `killed` marks a run terminated by a signal before it could reach any
- * of the others.
- */
-export type FireforgeVerdictReason = 'crash' | 'harness-arguments' | 'no-tests' | 'test-failures' | 'server-startup' | 'preflight' | 'inconclusive' | 'lock-timeout' | 'killed';
-/** Additive keys a run can stamp on its verdict line. */
-export type VerdictRunAttributeKey = 'shuffle' | 'orphans-reaped' | 'host-load' | 'host-cpu-warning' | 'power-source' | 'power-changed' | 'furnace-applied' | 'furnace-apply' | 'furnace-skipped' | 'control-build' | 'control-restore-build' | 'build-id' | 'drift-tolerated' | 'lock' | 'jobs' | 'upload-dirs' | 'results';
-/** Records an additive attribute for this run's verdict line. */
-export declare function setVerdictRunAttribute(key: VerdictRunAttributeKey, value: string): void;
-/**
- * Adds to a counting attribute. The key appears only once the total is
- * positive, so a run that reaped nothing prints the line it always did.
- * Sums across the preflight census, every retry attempt and every shard.
- */
-export declare function addVerdictRunCount(key: 'orphans-reaped', count: number): void;
-/**
- * Re-arms the verdict sink for a new run. Called at `testCommand` entry so
- * repeated programmatic invocations (and tests) each get their own
- * exactly-one-line guarantee.
- */
-export declare function resetVerdictEmission(): void;
-/** True once this run has written its `FIREFORGE-VERDICT:` line. */
-export declare function verdictEmitted(): boolean;
-/** Installs (or, with `undefined`, removes) the sub-run capture slot. */
-export declare function setVerdictCapture(slot: {
-    line?: string;
-} | undefined): void;
-/**
- * Emits a multi-run aggregate verdict. `body` is everything after the
- * `FIREFORGE-VERDICT: ` prefix.
- */
-export declare function emitAggregateVerdict(body: string): void;
-/**
- * Emits the classifier-derived verdict for a completed harness run, with
- * the aggregate `shards=<passed>/<total>` suffix for sharded runs.
- */
-export declare function emitHarnessVerdict(verdict: HarnessRunVerdict, shards?: {
-    passed: number;
-    total: number;
-    failed?: readonly string[];
-}): void;
-/** Emits the pathless `--doctor` PASS verdict. */
-export declare function emitPassVerdict(): void;
-/**
- * Emits a FAIL verdict carrying an emission-layer reason code, and
- * optionally the refusal class that produced it.
- *
- * `note=` is additive, like the `log=`, `signal=`, `shards=` and `shuffle=` keys already
- * on this line: `reason=` is unchanged and still comes from the closed set
- * in `docs/machine-output.md`, so a consumer that tokenises `key=value`
- * pairs is unaffected. It exists because `reason=preflight` covers every
- * gate before the harness (a missing build, a peer's packaging record, a
- * developer browser holding the objdir), and an unattended reader whose
- * pipe kept only the verdict line could not tell those apart.
- *
- * @param reason - Closed-set verdict reason
- * @param note - Stable refusal class, when the thrower named one
- */
-export declare function emitFailVerdict(reason: FireforgeVerdictReason, note?: string): void;
-/**
- * What ended a killed run: a signal FireForge received, or `parent-exit`,
- * the parent-death watchdog's finding that the process above FireForge
- * vanished (typically SIGKILLed by a supervisor) while a harness ran.
- */
-export type KilledVerdictCause = NodeJS.Signals | 'parent-exit';
-/**
- * Emits the terminal verdict for a run killed by a signal, or ended by
- * FireForge itself because its parent died.
- *
- * Without it a killed run wrote no terminal line, so a log tail could not
- * distinguish "killed" from "still running" from "never started". Recovery
- * meant checking `ps` and the lock file by hand, at the exact moment (a
- * mass kill under a usage limit, mid-drain) when the tree's state most
- * needs to be readable. A no-op unless a run was actually in flight: the
- * line asserts a test run happened, and an interrupted `status` did not
- * have one.
- *
- * @param signal - The signal that terminated the run, or `parent-exit`
- * @returns True when a line was written
- */
-export declare function emitKilledVerdict(signal: KilledVerdictCause): boolean;

package/dist/src/commands/test-verdict.js

@@ -1,162 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { getActiveRunLogPath } from '../core/run-log.js';
-import { formatFireforgeVerdictLine } from '../core/test-harness-crash.js';
-import { setStdoutSealed } from '../utils/logger.js';
-let emitted = false;
-/**
- * Additive `key=value` attributes of the run in flight, appended to
- * whichever verdict line ends it. `shuffle` is the seed a `--shuffle` run
- * exported to the harness, so a red found by shuffling carries its own
- * reproduction on the one line an unattended reader keeps. `orphans-reaped`
- * is how many harness processes FireForge had to terminate itself, at
- * preflight (survivors of an earlier run) or at teardown (helpers this run
- * launched that outlived mach): a green after a reap is not the same
- * finding as a green on a quiet machine. Cleared by
- * {@link resetVerdictEmission}, so a later run in the same process cannot
- * inherit them.
- */
-const runAttributes = new Map();
-/** Records an additive attribute for this run's verdict line. */
-export function setVerdictRunAttribute(key, value) {
-    runAttributes.set(key, value);
-}
-/**
- * Adds to a counting attribute. The key appears only once the total is
- * positive, so a run that reaped nothing prints the line it always did.
- * Sums across the preflight census, every retry attempt and every shard.
- */
-export function addVerdictRunCount(key, count) {
-    // Written as a negated `> 0` so a NaN (a stubbed census, a bad parse) is
-    // dropped rather than stamped on the line as `orphans-reaped=NaN`.
-    if (!(count > 0))
-        return;
-    const current = Number(runAttributes.get(key) ?? '0');
-    runAttributes.set(key, String(current + count));
-}
-/**
- * True once a test run has begun in this process.
- *
- * The signal path needs it: a `FIREFORGE-VERDICT` line claims a test run
- * happened, and a Ctrl+C during `fireforge status` must not print one. Set
- * by {@link resetVerdictEmission}, which `testCommand` already calls at
- * entry, so nothing else has to remember to arm it.
- */
-let armed = false;
-/**
- * Re-arms the verdict sink for a new run. Called at `testCommand` entry so
- * repeated programmatic invocations (and tests) each get their own
- * exactly-one-line guarantee.
- */
-export function resetVerdictEmission() {
-    emitted = false;
-    armed = true;
-    runAttributes.clear();
-    capture = undefined;
-    setStdoutSealed(false);
-}
-/**
- * The sub-run capture slot of a multi-run invocation (`--repeat`, mixed
- * harnesses, `--negative-control`; see `test-orchestrate.ts`). While one is
- * installed, a sub-run's verdict line is recorded here, first write wins as
- * on stdout, and nothing is printed or sealed, so the invocation can still
- * end with its own single aggregate line.
- */
-let capture;
-/** True once this run has written its `FIREFORGE-VERDICT:` line. */
-export function verdictEmitted() {
-    return capture === undefined ? emitted : capture.line !== undefined;
-}
-/** Installs (or, with `undefined`, removes) the sub-run capture slot. */
-export function setVerdictCapture(slot) {
-    capture = slot;
-}
-/**
- * Emits a multi-run aggregate verdict. `body` is everything after the
- * `FIREFORGE-VERDICT: ` prefix.
- */
-export function emitAggregateVerdict(body) {
-    writeVerdictLine(`FIREFORGE-VERDICT: ${body}`);
-}
-/**
- * Writes the run's single verdict line to raw stdout (clack's renderer can
- * drop output under non-TTY capture). First write wins. Every later call
- * is a no-op: the writer closest to the harness result runs first, so the
- * fallback layers (the engine-generation guard, the preflight wrapper)
- * can emit unconditionally without risking a second line. Writing also
- * seals stdout: the verdict must stay the run's last stdout write, so all
- * subsequent logger output, including the CLI-boundary error/cancel
- * rendering after an emit-then-throw path, routes to stderr.
- */
-function writeVerdictLine(line) {
-    if (capture !== undefined) {
-        capture.line ??= line;
-        return;
-    }
-    if (emitted)
-        return;
-    emitted = true;
-    // The run log's path rides the verdict line because the verdict must stay
-    // the run's last stdout write: a separate announcement after it would
-    // break that contract, and one before it is the first thing a `tail` cuts.
-    // Appended as an additive `key=value`, so consumers that tokenize the line
-    // are unaffected and a truncated tail still says where the full output is.
-    const attributes = [...runAttributes].map(([key, value]) => ` ${key}=${value}`).join('');
-    const logPath = getActiveRunLogPath();
-    const suffix = logPath === undefined ? '' : ` log=${logPath}`;
-    process.stdout.write(`${line}${attributes}${suffix}\n`);
-    setStdoutSealed(true);
-}
-/**
- * Emits the classifier-derived verdict for a completed harness run, with
- * the aggregate `shards=<passed>/<total>` suffix for sharded runs.
- */
-export function emitHarnessVerdict(verdict, shards) {
-    writeVerdictLine(formatFireforgeVerdictLine(verdict, shards));
-}
-/** Emits the pathless `--doctor` PASS verdict. */
-export function emitPassVerdict() {
-    writeVerdictLine('FIREFORGE-VERDICT: PASS');
-}
-/**
- * Emits a FAIL verdict carrying an emission-layer reason code, and
- * optionally the refusal class that produced it.
- *
- * `note=` is additive, like the `log=`, `signal=`, `shards=` and `shuffle=` keys already
- * on this line: `reason=` is unchanged and still comes from the closed set
- * in `docs/machine-output.md`, so a consumer that tokenises `key=value`
- * pairs is unaffected. It exists because `reason=preflight` covers every
- * gate before the harness (a missing build, a peer's packaging record, a
- * developer browser holding the objdir), and an unattended reader whose
- * pipe kept only the verdict line could not tell those apart.
- *
- * @param reason - Closed-set verdict reason
- * @param note - Stable refusal class, when the thrower named one
- */
-export function emitFailVerdict(reason, note) {
-    const suffix = note === undefined ? '' : ` note=${note}`;
-    writeVerdictLine(`FIREFORGE-VERDICT: FAIL reason=${reason}${suffix}`);
-}
-/**
- * Emits the terminal verdict for a run killed by a signal, or ended by
- * FireForge itself because its parent died.
- *
- * Without it a killed run wrote no terminal line, so a log tail could not
- * distinguish "killed" from "still running" from "never started". Recovery
- * meant checking `ps` and the lock file by hand, at the exact moment (a
- * mass kill under a usage limit, mid-drain) when the tree's state most
- * needs to be readable. A no-op unless a run was actually in flight: the
- * line asserts a test run happened, and an interrupted `status` did not
- * have one.
- *
- * @param signal - The signal that terminated the run, or `parent-exit`
- * @returns True when a line was written
- */
-export function emitKilledVerdict(signal) {
-    if (!armed || emitted)
-        return false;
-    // A kill ends the whole invocation, so a sub-run capture must not
-    // swallow the one line that says so.
-    capture = undefined;
-    writeVerdictLine(`FIREFORGE-VERDICT: FAIL reason=killed signal=${signal}`);
-    return true;
-}

package/dist/src/commands/test.d.ts

@@ -1,22 +0,0 @@
-import type { TestOptions } from '../types/commands/index.js';
-/**
- * Runs the test command to execute mach tests.
- *
- * Owns the run's exactly-one-`FIREFORGE-VERDICT:`-line guarantee: the sink
- * is re-armed at entry, and any failure that reaches this boundary without
- * an inner writer having emitted (the preflight ladder: missing engine or
- * build, config errors, stale-build and port gates, missing paths, and a
- * harness process that failed to start) emits `FAIL reason=preflight`,
- * since no harness classification exists for such a run. Writers closer to
- * the harness (doctor, canary, single, sharded, the engine-generation
- * guard) emit first and win.
- * The lock-free checks (launchable binary, named-file checkJs, the
- * `--wait-browser`/`--wait-port` budgets) run first, outside `underLock`,
- * so a run that would be refused or would only wait never holds a place in
- * the engine lock queue. See `test-prelock.ts`.
- * @param projectRoot - Root directory of the project
- * @param testPaths - Test file or directory paths
- * @param options - Test options
- * @param underLock - Runs the rest of the command under the engine session lock
- */
-export declare function testCommand(projectRoot: string, testPaths: string[], options?: TestOptions, underLock?: (body: () => Promise<void>, mode?: 'exclusive' | 'shared') => Promise<void>): Promise<void>;

package/dist/src/commands/token-coverage.d.ts

@@ -1,5 +0,0 @@
-/**
- * Measures design token coverage across modified CSS files.
- * @param projectRoot - Root directory of the project
- */
-export declare function tokenCoverageCommand(projectRoot: string): Promise<void>;