@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/build-baseline-types.d.ts

@@ -1,225 +0,0 @@
-/**
- * Type of the last-build baseline marker, split out of `build-baseline.ts`
- * so its consumers (`build-audit`, `build-prepare`, `test-stale-check`) can
- * import the shape without importing the I/O module. `build-baseline.ts`
- * itself depends on `build-audit.ts` at runtime, and a type import back
- * into it would make the dependency graph cyclic.
- */
-/** Shape of the on-disk baseline marker. */
-export declare const DELETED_FILE_FINGERPRINT = "<deleted>";
-export interface BuildBaseline {
-    /** SHA of engine HEAD at the time the build succeeded. */
-    engineHeadSha: string;
-    /**
-     * ISO-8601 timestamp of when the baseline was recorded. Informational:
-     * downstream code keys off `engineHeadSha` for diffs, but the timestamp
-     * helps operators reason about stale markers.
-     */
-    builtAt: string;
-    /**
-     * The binaryName used at build time. Captured so the dist-tree audit
-     * can resolve the expected bundle root under obj-star/dist/ even when
-     * the project has since been renamed.
-     */
-    binaryName: string;
-    /**
-     * Content hash per packageable engine path that was dirty at build time
-     * (modified-against-HEAD or untracked). Used by `checkStaleBuildForTest`
-     * to distinguish "this file's content was already in `dist/` when the
-     * build completed" from "this file has been edited since". When absent,
-     * the stale-check falls back to a path-only comparison.
-     *
-     * Keys are engine-relative POSIX paths. Values are hex-encoded SHA-256
-     * digests of the file contents at the moment the baseline was recorded,
-     * or {@link DELETED_FILE_FINGERPRINT} when the successful build observed
-     * a tracked deletion.
-     */
-    packageableFingerprints?: Record<string, string>;
-    /**
-     * All dirty staging inputs, including plain test scripts and support fixtures.
-     * Omitted when any input could not be fingerprinted; a partial map cannot
-     * anchor retained coverage.
-     */
-    testInputFingerprints?: Record<string, string>;
-    /**
-     * Content hash per build-input manifest (`jar.mn`, `moz.build`,
-     * `moz.configure`, `Makefile.in`, `mozbuild.in`) that was dirty
-     * (modified-against-HEAD or untracked) when the recorded build succeeded.
-     * Same key/value shape as {@link BuildBaseline.packageableFingerprints}.
-     *
-     * Consumed by `build-prepare`: a dirty build input whose live hash still
-     * matches its entry was already consumed by the recorded build, so it
-     * neither re-runs `mach configure` nor escalates a pre-test build to a
-     * full `mach build`. Without this the persistent worktree diff every
-     * fork carries (imported patches + Furnace-applied components) made a
-     * patch-touched `jar.mn` "changed" on every run, and each `test --build`
-     * after a full build paid the full build again.
-     *
-     * Refresh rules, per entry kind:
-     * - backend inputs (`moz.build` & co) are refreshed on every successful
-     *   write, because every baseline-writing path ran the auto-configure
-     *   preflight against the previous baseline, so a changed one was
-     *   reconfigured.
-     * - `jar.mn` entries are refreshed only by a full build and carried
-     *   forward verbatim from the previous record on a `faster` write, since
-     *   `fireforge build --ui` never escalates and recording a `jar.mn` no
-     *   full build has installed would hide the next escalation.
-     *
-     * Absent on baselines written before the field existed. `build-prepare`
-     * then falls back to the path-only comparison (every dirty build input
-     * counts as changed).
-     */
-    buildInputFingerprints?: Record<string, string>;
-    /**
-     * What the packaged test runtime produced by the recorded build covers.
-     *
-     * - `'full'`: the build packaged the full test set, written by
-     *   `fireforge build` / `build --ui` and by a path-less
-     *   `fireforge test --build` (full-suite run).
-     * - `string[]`: engine-relative POSIX request paths of the file/directory-
-     *   scoped `fireforge test --build` invocation that produced the runtime.
-     *   A directory entry covers everything beneath it. Support fixtures for
-     *   manifests outside this list may be missing from `obj-*`/`_tests/`, so
-     *   an `--allow-stale-build` run over uncovered paths is refused rather
-     *   than dispatched into a hang.
-     *
-     * An absent field is treated as full coverage.
-     *
-     * The record is project-scoped, which is also per-obj-dir: multi-objdir
-     * checkouts are refused up-front (`AmbiguousBuildArtifactsError`), so at
-     * most one obj dir exists per project.
-     *
-     * Successive scoped builds retain the previous claim only when HEAD,
-     * mozconfig and complete testInputFingerprints outside the rebuilt scope
-     * remain anchored. Explicitly rebuilt paths may change. A failed anchor
-     * replaces coverage with a dropped-path notice, or refuses when the caller
-     * required --extend-coverage. Anchors that fingerprint only packageable
-     * inputs cannot retain coverage because they cannot prove test scripts and
-     * fixtures unchanged.
-     *
-     * Retention is decided per staged path: see
-     * {@link BuildBaseline.testCoverageRecords} and
-     * {@link BuildBaseline.fullCoverageAnchor}.
-     */
-    testPackagingCoverage?: TestPackagingCoverage;
-    /**
-     * Per-path anchors of a scoped claim, keyed by the request path in
-     * {@link BuildBaseline.testPackagingCoverage}. Each record holds that
-     * path's own staging inputs and their content at the build that staged
-     * it, so a later scoped build keeps the path while those inputs are
-     * unchanged, whatever moved elsewhere in the engine. A listed path without
-     * a record falls back to the baseline-wide anchor. Absent on full claims.
-     */
-    testCoverageRecords?: Record<string, CoverageRecord>;
-    /**
-     * The anchor of the last full-coverage build, carried forward by scoped
-     * builds once something outside their scope moved. A request path outside
-     * the scoped list stays covered while its own staging inputs are unchanged
-     * against this anchor. The check runs at dispatch, per requested path.
-     */
-    fullCoverageAnchor?: CoverageAnchor;
-    /**
-     * Hex-encoded SHA-256 of `engine/mozconfig` as it stood for this build.
-     * Recorded because the mozconfig is regenerated from project-side
-     * `configs/*.mozconfig` templates plus `fireforge.json` on every build, so
-     * `engineHeadSha` does not cover it: two builds at the same engine SHA can
-     * configure differently. Consumed by the `--extend-coverage` anchor, which
-     * refuses when the field is absent (one plain build re-records it).
-     */
-    mozconfigHash?: string;
-    /**
-     * Anchor for the compiled StaticComponents table: the engine HEAD SHA of
-     * the last full-coverage build plus content fingerprints of the
-     * `components.conf` manifests that were dirty at that moment. Written
-     * fresh only on full-coverage baseline writes (`fireforge build`,
-     * `build --ui`, path-less `test --build`). A scoped `test --build` carries
-     * the previous record forward verbatim, because `mach build faster` does
-     * not rebake `components.conf` registrations into the compiled table. When
-     * absent, the static-components stale check degrades to "fresh".
-     */
-    staticComponentsBaseline?: StaticComponentsBaseline;
-    /**
-     * Invocation shape that recorded this baseline (`'fireforge build'`,
-     * `'fireforge build --ui'`, `'fireforge test --build [paths]'`).
-     * Informational, surfaced by `fireforge status --test-coverage`. Render
-     * as "unknown" when absent.
-     */
-    recordedBy?: string;
-    /**
-     * The process that wrote this baseline: its pid, its invocation id (the
-     * one its history records carry) and the caller's `FIREFORGE_SESSION_ID`
-     * when set. A coverage refusal names it, so a run whose claim another
-     * session's scoped build replaced can tell whose build that was.
-     */
-    recorder?: BaselineRecorder;
-    /**
-     * Set when this build compiled a negative control into the binary
-     * (`test --negative-control --build` on compiled source). The source is
-     * restored byte-exact after the run, but the objdir binary keeps the
-     * mutation until a build recompiles it. FireForge runs that restore build
-     * itself, inside the same lock hold, and its baseline drops the stamp.
-     * A stamp still present (the run was killed, or the restore build
-     * failed) makes the next `fireforge test` refuse with `control-built`
-     * until `fireforge build` replaces the baseline.
-     */
-    controlBuild?: ControlBuildStamp;
-}
-/** See {@link BuildBaseline.controlBuild}. */
-export interface ControlBuildStamp {
-    /** The `--negative-control` diff file, as given. */
-    diffFile: string;
-    /** Engine-relative compiled targets the control edited. */
-    targets: string[];
-    /** ISO-8601 time the control was applied. */
-    appliedAt: string;
-}
-/** See {@link BuildBaseline.recorder}. */
-export interface BaselineRecorder {
-    pid: number;
-    invocationId: string;
-    sessionId?: string;
-}
-/**
- * State of the engine at the last full build, as far as compiled-in XPCOM
- * component registration is concerned. See
- * {@link BuildBaseline.staticComponentsBaseline}.
- */
-export interface StaticComponentsBaseline {
-    /** Engine HEAD SHA at the time of the last full build. */
-    engineHeadSha: string;
-    /**
-     * Hex-encoded SHA-256 per `components.conf` path that was dirty
-     * (modified-against-HEAD or untracked) when the full build ran. A tracked
-     * deletion is represented by {@link DELETED_FILE_FINGERPRINT}. Keys are
-     * engine-relative POSIX paths.
-     */
-    fingerprints: Record<string, string>;
-}
-/**
- * Content anchor of one packaging claim. A path's staged content is
- * `fingerprints[path]` when recorded, otherwise its content at
- * `engineHeadSha`.
- */
-export interface CoverageAnchor {
-    /** Engine HEAD the staged content is relative to. */
-    engineHeadSha: string;
-    /** Hex SHA-256 of `engine/mozconfig` the claim was configured with. */
-    mozconfigHash: string;
-    /**
-     * Hex SHA-256 (or {@link DELETED_FILE_FINGERPRINT}) per engine-relative
-     * path whose staged content differs from `engineHeadSha`.
-     */
-    fingerprints: Record<string, string>;
-}
-/** Anchor of one staged request path. See {@link BuildBaseline.testCoverageRecords}. */
-export interface CoverageRecord extends CoverageAnchor {
-    /**
-     * Engine-relative paths (files or directories) whose content decides what
-     * the harness stages for the request path: its manifest directory plus
-     * whatever a manifest there names outside it. `fingerprints` is
-     * restricted to these.
-     */
-    inputs: string[];
-}
-/** Coverage claim of the packaged test runtime. See {@link BuildBaseline.testPackagingCoverage}. */
-export type TestPackagingCoverage = 'full' | string[];

package/dist/src/core/build-baseline-types.js

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Type of the last-build baseline marker, split out of `build-baseline.ts`
- * so its consumers (`build-audit`, `build-prepare`, `test-stale-check`) can
- * import the shape without importing the I/O module. `build-baseline.ts`
- * itself depends on `build-audit.ts` at runtime, and a type import back
- * into it would make the dependency graph cyclic.
- */
-/** Shape of the on-disk baseline marker. */
-export const DELETED_FILE_FINGERPRINT = '<deleted>';

package/dist/src/core/build-baseline-validate.d.ts

@@ -1,32 +0,0 @@
-import { type BuildBaseline } from './build-baseline-types.js';
-/**
- * The first field of a persisted baseline that fails validation, and the
- * offending value: what a refusal names so the operator can tell a scoped
- * coverage claim from a corrupt marker.
- */
-export interface BuildBaselineProblem {
-    /** Field path, e.g. `testPackagingCoverage[2]` or `testCoverageRecords["a/"]`. */
-    field: string;
-    /** The offending value, as found (may be any JSON value). */
-    value: unknown;
-}
-/** True when the problem sits in a packaging-coverage field. */
-export declare function isCoverageProblem(problem: BuildBaselineProblem): boolean;
-/** Renders a problem for a refusal: the field and a bounded JSON rendering of its value. */
-export declare function describeBuildBaselineProblem(problem: BuildBaselineProblem): string;
-/**
- * Validates persisted fields without converting malformed coverage into a
- * full claim, and returns the first failing field with its value, or
- * undefined when the baseline is valid.
- *
- * @param value - The parsed `last-build.json`
- */
-export declare function findBuildBaselineProblem(value: unknown): BuildBaselineProblem | undefined;
-/**
- * Validates persisted fields without converting malformed coverage into a
- * full claim. The boolean form of {@link findBuildBaselineProblem}.
- *
- * @internal Exported only so tests can reach it. Production reads go
- * through `findBuildBaselineProblem`, which names the failing field.
- */
-export declare function isBuildBaseline(value: unknown): value is BuildBaseline;

package/dist/src/core/build-baseline-validate.js

@@ -1,173 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { isObject } from '../utils/validation.js';
-import { DELETED_FILE_FINGERPRINT } from './build-baseline-types.js';
-/** Baseline paths are engine-relative POSIX identifiers, never filesystem escapes. */
-function isBaselinePath(value) {
-    return (typeof value === 'string' &&
-        value.length > 0 &&
-        !value.includes('\0') &&
-        !value.includes('\\') &&
-        !value.includes(':') &&
-        value.split('/').every((part) => part.length > 0 && part !== '.' && part !== '..'));
-}
-function isFingerprint(value) {
-    return (typeof value === 'string' &&
-        (/^[a-f0-9]{64}$/i.test(value) || value === DELETED_FILE_FINGERPRINT));
-}
-function isFingerprintMap(value) {
-    return (isObject(value) &&
-        Object.entries(value).every(([path, fingerprint]) => isBaselinePath(path) && isFingerprint(fingerprint)));
-}
-function isCoverageAnchor(value) {
-    return (isObject(value) &&
-        typeof value['engineHeadSha'] === 'string' &&
-        isFingerprint(value['mozconfigHash']) &&
-        isFingerprintMap(value['fingerprints']));
-}
-/** A `controlBuild` stamp: the control's diff file, its targets and when it went in. */
-function isControlBuildStamp(value) {
-    return (isObject(value) &&
-        typeof value['diffFile'] === 'string' &&
-        Array.isArray(value['targets']) &&
-        value['targets'].every(isBaselinePath) &&
-        typeof value['appliedAt'] === 'string' &&
-        Number.isFinite(Date.parse(value['appliedAt'])));
-}
-/** A `recorder` stamp: an integer pid, an invocation id and an optional session id. */
-function isBaselineRecorder(value) {
-    return (isObject(value) &&
-        Number.isInteger(value['pid']) &&
-        typeof value['invocationId'] === 'string' &&
-        (value['sessionId'] === undefined || typeof value['sessionId'] === 'string'));
-}
-/** Fields whose problem a scoped `test --build` can leave and a fresh one replaces. */
-const COVERAGE_FIELDS = ['testPackagingCoverage', 'testCoverageRecords', 'fullCoverageAnchor'];
-/** True when the problem sits in a packaging-coverage field. */
-export function isCoverageProblem(problem) {
-    return COVERAGE_FIELDS.some((field) => problem.field === field ||
-        problem.field.startsWith(`${field}[`) ||
-        problem.field.startsWith(`${field}.`));
-}
-/** Renders a problem for a refusal: the field and a bounded JSON rendering of its value. */
-export function describeBuildBaselineProblem(problem) {
-    let rendered;
-    try {
-        // JSON.stringify(undefined) returns undefined at runtime despite its type.
-        const json = JSON.stringify(problem.value);
-        rendered = json ?? 'undefined';
-    }
-    catch {
-        rendered = String(problem.value);
-    }
-    if (rendered.length > 120)
-        rendered = `${rendered.slice(0, 117)}...`;
-    return `${problem.field} = ${rendered}`;
-}
-function findFingerprintMapProblem(field, value) {
-    if (!isObject(value))
-        return { field, value };
-    for (const [path, fingerprint] of Object.entries(value)) {
-        if (!isBaselinePath(path))
-            return { field: `${field}[${JSON.stringify(path)}]`, value: path };
-        if (!isFingerprint(fingerprint)) {
-            return { field: `${field}[${JSON.stringify(path)}]`, value: fingerprint };
-        }
-    }
-    return undefined;
-}
-function findCoverageRecordProblem(value) {
-    const field = 'testCoverageRecords';
-    if (!isObject(value))
-        return { field, value };
-    for (const [path, record] of Object.entries(value)) {
-        const entry = `${field}[${JSON.stringify(path)}]`;
-        if (!isBaselinePath(path))
-            return { field: entry, value: path };
-        if (!isCoverageAnchor(record) || !isObject(record) || !Array.isArray(record['inputs'])) {
-            return { field: entry, value: record };
-        }
-        const inputs = record['inputs'];
-        const input = inputs.find((item) => !isBaselinePath(item));
-        if (input !== undefined)
-            return { field: `${entry}.inputs`, value: input };
-    }
-    return undefined;
-}
-/**
- * Validates persisted fields without converting malformed coverage into a
- * full claim, and returns the first failing field with its value, or
- * undefined when the baseline is valid.
- *
- * @param value - The parsed `last-build.json`
- */
-export function findBuildBaselineProblem(value) {
-    if (!isObject(value))
-        return { field: '(root)', value };
-    if (typeof value['engineHeadSha'] !== 'string') {
-        return { field: 'engineHeadSha', value: value['engineHeadSha'] };
-    }
-    if (typeof value['builtAt'] !== 'string' || !Number.isFinite(Date.parse(value['builtAt']))) {
-        return { field: 'builtAt', value: value['builtAt'] };
-    }
-    if (typeof value['binaryName'] !== 'string' || !/^[a-z][a-z0-9-]*$/.test(value['binaryName'])) {
-        return { field: 'binaryName', value: value['binaryName'] };
-    }
-    for (const field of [
-        'packageableFingerprints',
-        'testInputFingerprints',
-        'buildInputFingerprints',
-    ]) {
-        if (value[field] === undefined)
-            continue;
-        const problem = findFingerprintMapProblem(field, value[field]);
-        if (problem !== undefined)
-            return problem;
-    }
-    const coverage = value['testPackagingCoverage'];
-    if (coverage !== undefined && coverage !== 'full') {
-        if (!Array.isArray(coverage))
-            return { field: 'testPackagingCoverage', value: coverage };
-        const index = coverage.findIndex((path) => !isBaselinePath(path));
-        if (index >= 0) {
-            return { field: `testPackagingCoverage[${index}]`, value: coverage[index] };
-        }
-    }
-    if (value['mozconfigHash'] !== undefined && !isFingerprint(value['mozconfigHash'])) {
-        return { field: 'mozconfigHash', value: value['mozconfigHash'] };
-    }
-    if (value['recordedBy'] !== undefined && typeof value['recordedBy'] !== 'string') {
-        return { field: 'recordedBy', value: value['recordedBy'] };
-    }
-    if (value['recorder'] !== undefined && !isBaselineRecorder(value['recorder'])) {
-        return { field: 'recorder', value: value['recorder'] };
-    }
-    if (value['testCoverageRecords'] !== undefined) {
-        const problem = findCoverageRecordProblem(value['testCoverageRecords']);
-        if (problem !== undefined)
-            return problem;
-    }
-    if (value['fullCoverageAnchor'] !== undefined && !isCoverageAnchor(value['fullCoverageAnchor'])) {
-        return { field: 'fullCoverageAnchor', value: value['fullCoverageAnchor'] };
-    }
-    const components = value['staticComponentsBaseline'];
-    if (components !== undefined &&
-        !(isObject(components) &&
-            typeof components['engineHeadSha'] === 'string' &&
-            isFingerprintMap(components['fingerprints']))) {
-        return { field: 'staticComponentsBaseline', value: components };
-    }
-    if (value['controlBuild'] !== undefined && !isControlBuildStamp(value['controlBuild'])) {
-        return { field: 'controlBuild', value: value['controlBuild'] };
-    }
-    return undefined;
-}
-/**
- * Validates persisted fields without converting malformed coverage into a
- * full claim. The boolean form of {@link findBuildBaselineProblem}.
- *
- * @internal Exported only so tests can reach it. Production reads go
- * through `findBuildBaselineProblem`, which names the failing field.
- */
-export function isBuildBaseline(value) {
-    return findBuildBaselineProblem(value) === undefined;
-}

package/dist/src/core/build-baseline.d.ts

@@ -1,103 +0,0 @@
-/**
- * Persists a marker describing the state of the engine tree at the time of
- * the last successful `fireforge build`. Two downstream consumers share this
- * marker:
- *
- *   - `build-audit`: after a build succeeds, compare engine files touched
- *     since the baseline against the dist bundle to flag silent
- *     packaging drops (e.g. a pref file never registered in moz.build).
- *   - `build-prepare`: before a build starts, detect whether any
- *     `moz.build` / `moz.configure` / `Makefile.in` changed since the
- *     baseline and run `mach configure` before the build step so the
- *     recursive-make backend isn't stale.
- *
- * The marker lives under `.fireforge/last-build.json`. It is written only
- * on successful build completion. A failed build does not update it, so a
- * subsequent run still audits against the last known-good tree.
- */
-import { type BuildBaseline, type ControlBuildStamp, type CoverageAnchor, type CoverageRecord, type TestPackagingCoverage } from './build-baseline-types.js';
-/**
- * Which mach build produced the baseline being written. Decides whether
- * the `jar.mn` half of {@link BuildBaseline.buildInputFingerprints} is
- * refreshed (`'full'`) or carried forward from the previous record
- * (`'faster'`). `fireforge build --ui` and a non-escalated `test --build`
- * are `'faster'`. `fireforge build` and an escalated `test --build` are
- * `'full'`.
- */
-export type BaselineBuildKind = 'full' | 'faster';
-/**
- * Resolves the on-disk path of the build baseline marker.
- * @param projectRoot - Root directory of the project
- * @returns Absolute path of the marker file
- */
-export declare function getBuildBaselinePath(projectRoot: string): string;
-/**
- * Reads the last-build baseline if present. Returns undefined when no
- * previous successful build has been recorded. Builds can replace invalid
- * markers; dispatch preflights pass `refuse` so invalid coverage never
- * becomes the implicit full claim of a baseline without coverage.
- * @param projectRoot - Root directory of the project
- */
-export declare function readBuildBaseline(projectRoot: string, invalid?: 'ignore' | 'refuse'): Promise<BuildBaseline | undefined>;
-export interface WriteBuildBaselineOptions {
-    /** Root directory of the project. */
-    projectRoot: string;
-    /** Path to the engine directory. */
-    engineDir: string;
-    /** Current `binaryName` from fireforge.json. */
-    binaryName: string;
-    /**
-     * Coverage claim of the packaged test runtime this build produced
-     * (`'full'`, or the scoped request paths of a `test --build` invocation).
-     * Omitted → field left off the marker.
-     */
-    testPackagingCoverage?: TestPackagingCoverage | undefined;
-    /** Per-path anchors of a scoped claim. Omitted → field left off the marker. */
-    testCoverageRecords?: Record<string, CoverageRecord> | undefined;
-    /** Carried full-build anchor of a narrowed claim. Omitted → field left off. */
-    fullCoverageAnchor?: CoverageAnchor | undefined;
-    /**
-     * The baseline this write replaces, when the caller has it. A scoped
-     * (non-`'full'`) write carries its `staticComponentsBaseline` forward
-     * verbatim, because `mach build faster` does not rebake `components.conf`
-     * registrations, so the last full build stays the anchor for the
-     * compiled StaticComponents table.
-     */
-    previousBaseline?: BuildBaseline | undefined;
-    /** Invocation shape that produced this baseline. */
-    recordedBy?: string | undefined;
-    /**
-     * `'auto'` (default) refreshes the static-components anchor whenever the
-     * coverage claim is `'full'` or absent. `'refresh'` records it even for a
-     * scoped coverage claim whose implementation escalated to a full build.
-     * `'carry-forward'` always keeps the previous anchor: needed by
-     * `--extend-coverage`, whose union can evaluate to `'full'` while the
-     * build that produced it was still a scoped `mach build faster` that did
-     * not rebake the compiled table.
-     */
-    staticComponentsHandling?: 'auto' | 'refresh' | 'carry-forward' | undefined;
-    /**
-     * Which mach build produced this baseline (default `'full'`). A
-     * `'faster'` write carries the previous record's `jar.mn` fingerprints
-     * forward instead of refreshing them. See
-     * {@link BuildBaseline.buildInputFingerprints}. Every caller that ran
-     * `mach build faster` must say so, or the next pre-test build skips an
-     * escalation no full build has honoured.
-     */
-    buildKind?: BaselineBuildKind | undefined;
-    /**
-     * Stamp for a build that compiled a negative control into the binary.
-     * Omitted → field left off, which is how every other build clears it.
-     * See {@link BuildBaseline.controlBuild}.
-     */
-    controlBuild?: ControlBuildStamp | undefined;
-}
-/**
- * Records a successful build by writing a fresh baseline marker. Captures
- * engine HEAD SHA (or an empty string when the engine has no HEAD yet) and
- * the current binaryName. Caller is responsible for only invoking this
- * after the build exit code was zero.
- *
- * @param options - See {@link WriteBuildBaselineOptions}
- */
-export declare function writeBuildBaseline(options: WriteBuildBaselineOptions): Promise<void>;