@williamthorsen/nmr 0.48.0 → 0.50.0

package/dist/esm/check-cache-record.js

@@ -0,0 +1,167 @@
+import path from 'node:path';
+import { describeError } from '@williamthorsen/toolbelt.errors';
+import { isCacheableCommand, resolveTreeSnapshot, writeDebugNote } from "./check-cache.js";
+import { findStaleBuildOutput, readBuildOutputState } from "./check-cache-build-output.js";
+import { readCheckCacheEntry, recordTranscript, writeCheckCacheEntry, } from "./check-cache-entries.js";
+import { CURRENT_RUNTIME } from "./check-cache-key.js";
+import { deriveExcerpt } from "./helpers/deriveExcerpt.js";
+import { composeTranscript } from "./helpers/transcript.js";
+import { RUN_IF_PRESENT_ENV_VAR, VERSION } from "./invocation.js";
+import { writePassManifestEntry } from "./pass-manifest.js";
+import { renderRecording, renderRefusal, resolveRecording } from "./recording.js";
+import { assembleReplay } from "./replay-assembly.js";
+export async function recordHostPass(options) {
+    const { env, host, key, ref, retention, snapshot, stderr } = options;
+    const recorded = await readCheckCacheEntry(ref);
+    if (recorded !== undefined && recorded.host === undefined && recorded.key === key) {
+        const output = await readBuildOutputState(options.monorepoRoot, options.config);
+        if (output.missingPackages.length === 0 &&
+            findStaleBuildOutput(recorded.buildDigests, output.digests) === undefined) {
+            writeDebugNote(`not recording ${ref.command} on ${host}: a pass earned here covers this tree`, env, stderr);
+            return;
+        }
+    }
+    await writePass({
+        entry: {
+            key,
+            treeHash: snapshot.treeId,
+            headSha: snapshot.headSha,
+            commandString: options.commandString,
+            nmrVersion: VERSION,
+            nodeVersion: CURRENT_RUNTIME.nodeVersion,
+            durationMs: options.durationMs,
+            recordedAt: new Date().toISOString(),
+            buildDigests: {},
+            host,
+            ...(retention !== undefined && { retention }),
+        },
+        env,
+        ref,
+        retainedOutput: options.retainedOutput,
+        stderr,
+    });
+}
+export async function recordPass(options) {
+    const { anchorDir, command, env, monorepoRoot, snapshot, stderr } = options;
+    const currentRead = resolveTreeSnapshot({ monorepoRoot, env: {} });
+    if (!currentRead.ok) {
+        writeDebugNote(`not recording ${command}: ${currentRead.reason}`, env, stderr);
+        return;
+    }
+    if (currentRead.snapshot.treeId !== snapshot.treeId) {
+        writeDebugNote(`not recording ${command}: the tree changed while it ran`, env, stderr);
+        return;
+    }
+    const ref = { anchorDir, command, monorepoRoot };
+    const output = await readBuildOutputState(monorepoRoot, options.config);
+    const [missingPackage] = output.missingPackages;
+    if (missingPackage !== undefined) {
+        writeDebugNote(`not recording ${command}: ${missingPackage} does not have build output`, env, stderr);
+        return;
+    }
+    const changedPackage = findStaleBuildOutput(options.buildOutputBefore.digests, output.digests);
+    if (changedPackage !== undefined) {
+        writeDebugNote(`not recording ${command}: ${changedPackage}'s build output changed while it ran`, env, stderr);
+        return;
+    }
+    const retention = await composeRetention({
+        anchorDir,
+        command,
+        key: options.retentionKey,
+        monorepoRoot,
+        retainedOutput: options.retainedOutput,
+        runId: options.runId,
+        steps: options.ownSteps,
+        treeHash: snapshot.treeId,
+    });
+    const isWritten = await writePass({
+        entry: {
+            key: options.key,
+            treeHash: snapshot.treeId,
+            headSha: snapshot.headSha,
+            commandString: options.commandString,
+            nmrVersion: VERSION,
+            nodeVersion: CURRENT_RUNTIME.nodeVersion,
+            durationMs: options.durationMs,
+            recordedAt: new Date().toISOString(),
+            buildDigests: output.digests,
+            ...(retention !== undefined && { retention }),
+        },
+        env,
+        ref,
+        retainedOutput: options.retainedOutput,
+        stderr,
+    });
+    if (isWritten) {
+        await writePassManifestEntry({
+            anchorDir,
+            command,
+            commandString: options.commandString,
+            durationMs: options.durationMs,
+            env,
+            monorepoRoot,
+            replay: retention?.replay,
+            stderr,
+            treeHash: snapshot.treeId,
+        });
+    }
+}
+export async function reportRecording(plan) {
+    const { anchorDir, command, context, env, scope, stderr, stdout, styles } = plan.invocation;
+    const { config, monorepoRoot } = context;
+    const lookup = await resolveRecording({
+        anchorDir,
+        command,
+        currentIdentity: {
+            commandString: plan.commandString,
+            nmrVersion: VERSION,
+            nodeVersion: CURRENT_RUNTIME.nodeVersion,
+            treeHash: plan.snapshot?.treeId,
+        },
+        isCacheable: isCacheableCommand(config.checkCache, command),
+        key: plan.key,
+        monorepoRoot,
+    });
+    if (!lookup.ok) {
+        stderr.write(`${renderRefusal({ command, refusal: lookup.refusal, scope, style: styles.stderr })}\n`);
+        return { exitCode: env[RUN_IF_PRESENT_ENV_VAR] === '1' ? 0 : 1 };
+    }
+    stdout.write(renderRecording({ command, recording: lookup.recording, scope, style: styles.stdout }));
+    return { exitCode: 0 };
+}
+async function composeRetention(options) {
+    const { anchorDir, command, key, retainedOutput, runId } = options;
+    if (retainedOutput !== undefined) {
+        const excerpt = deriveExcerpt(retainedOutput.stdout.toString('utf8')) ?? deriveExcerpt(retainedOutput.stderr.toString('utf8'));
+        if (excerpt === undefined) {
+            return undefined;
+        }
+        return { key, replay: [{ command, excerpt, scope: path.basename(anchorDir) }], runId };
+    }
+    const replay = await assembleReplay({
+        anchorDir,
+        monorepoRoot: options.monorepoRoot,
+        runId,
+        steps: options.steps,
+        treeHash: options.treeHash,
+    });
+    return replay.length === 0 ? undefined : { key, replay, runId };
+}
+async function writePass(options) {
+    const { entry, env, ref, stderr } = options;
+    const transcript = options.retainedOutput === undefined ? undefined : composeTranscript(options.retainedOutput);
+    try {
+        await recordTranscript(ref, transcript);
+        await writeCheckCacheEntry({ ...ref, entry });
+        return true;
+    }
+    catch (error) {
+        try {
+            await recordTranscript(ref, undefined);
+        }
+        catch {
+        }
+        writeDebugNote(`could not record ${ref.command}: ${describeError(error)}`, env, stderr);
+        return false;
+    }
+}

package/dist/esm/check-cache.d.ts

@@ -1,75 +1,11 @@
 import type { Writable } from 'node:stream';
 import { type OutputStyle } from '@williamthorsen/nmr-core';
-import type { OutputChannels } from './runner.js';
-import type { CheckCacheConfig, NmrConfig } from './types.js';
-/** A recorded pass: what ran, on which tree, and how long it took. */
-export interface CheckCacheEntry {
-    /** The full cache key under which the pass was recorded; a hit is this key matching the key computed now. */
-    key: string;
-    treeHash: string;
-    headSha: string;
-    commandString: string;
-    nmrVersion: string;
-    nodeVersion: string;
-    durationMs: number;
-    /** ISO-8601 instant the pass completed. */
-    recordedAt: string;
-    /**
-     * The build digest that each covered package's output had when the pass was recorded. Build output is
-     * git-ignored, so the tree hash cannot describe it; comparing these separates output built from this tree from
-     * output that another tree left behind.
-     */
-    buildDigests: Record<string, string>;
-    /** What a skip replays in place of the run that it recalls, absent on a pass that retained nothing. */
-    retention?: Retention;
-}
-/** What locates one command's recorded pass at one scope, and the transcript beside it. */
-export interface EntryRef {
-    anchorDir: string;
-    command: string;
-    monorepoRoot: string;
-}
-/** One command's excerpt, attributed to the scope and the command that produced it. */
-export interface ReplayLine {
-    command: string;
-    excerpt: string;
-    scope: string;
-}
-/**
- * What a recalled pass replays, the key certifying the excerpts describe this environment's output, and the
- * run that last vouched for them.
- *
- * A list rather than one excerpt: a composite's entry contains its constituents' lines, and a nested one's are
- * spliced into its parent's, after which the attribution cannot be re-derived from the entry that contains them.
- *
- * The witness admits a constituent's line into the assembly that its parent records: a run writes it when it
- * records an excerpt, and restamps it when it recalls one and replays it.
- */
-export interface Retention {
-    key: string;
-    replay: ReplayLine[];
-    runId: string;
-}
-/** What nmr's own build has left on disk across the workspace. */
-export interface BuildOutputState {
-    /** Covered packages whose output is absent. */
-    missingPackages: string[];
-    /** The digest of the inputs from which each covered package's output was built, keyed by package name. */
-    digests: Record<string, string>;
-}
-/** The parts of the running interpreter that can change what a check concludes. */
-export interface RuntimeIdentity {
-    arch: string;
-    nodeVersion: string;
-    platform: string;
-}
+import type { CheckCacheConfig } from './types.js';
 /** One working tree, observed once per top-level invocation and shared with every process below it. */
 export interface TreeSnapshot {
-    hash: string;
+    treeId: string;
     headSha: string;
 }
-/** The interpreter on which this process is running, folded into every key and recorded alongside every pass. */
-export declare const CURRENT_RUNTIME: RuntimeIdentity;
 /** Set to `1` to hear why the gate did not skip, or why it is disabled. */
 export declare const DEBUG_ENV_VAR = "NMR_DEBUG";
 /**
@@ -85,76 +21,17 @@ export declare const DEBUG_ENV_VAR = "NMR_DEBUG";
 export declare const DEFAULT_CACHEABLE_COMMANDS: string[];
 /** Set to `1` for the standing equivalent of `--no-cache`: skip the lookup, still record on success. */
 export declare const NO_CACHE_ENV_VAR = "NMR_NO_CACHE";
+/**
+ * Names the directory into which every nmr process of a delegated run reports the passes that it records or recalls.
+ * Only the host session sets it, so that the delegating machine can learn a composite's constituent passes.
+ */
+export declare const PASS_MANIFEST_DIR_ENV_VAR = "NMR_PASS_MANIFEST_DIR";
 /** Passes one run's identity down the spawned chain, so that an entry can name the run that vouched for it. */
 export declare const RUN_ID_ENV_VAR = "NMR_RUN_ID";
 /** Passes the top-level tree snapshot down the spawned chain, to make one invocation hash the tree only once. */
 export declare const TREE_SNAPSHOT_ENV_VAR = "NMR_TREE_SNAPSHOT";
-/**
- * Restamps a recalled entry's retention with the run that is replaying it, so that an excerpt certified by this
- * run can join the assembly recorded by a composite above it.
- *
- * A recall certifies as surely as a recording does. Because the pass key matched, the excerpt describes this
- * tree; because the caller calls this only when the retention key matched too, the excerpt also describes this
- * presentation environment. Everything else the entry records stands -- the instant and the duration belong to
- * the run that earned the pass, and a recall must not make it read as later or longer than it was.
- *
- * A cache that cannot be written is not worth failing a green run over: `certifyRetention` reports that failure
- * in the debug note.
- */
-export declare function certifyRetention(options: {
-    anchorDir: string;
-    command: string;
-    entry: CheckCacheEntry;
-    env: NodeJS.ProcessEnv;
-    monorepoRoot: string;
-    runId: string;
-    stderr: Writable;
-}): Promise<void>;
-/**
- * Folds everything that can change what a command concludes into one key: the tree's content, the command
- * string that would run, the scope in which it would run, nmr's own version, the interpreter, what is installed,
- * and the environment variables that a check can read. A hit is this key matching a recorded one, so an ingredient left
- * out here is an ingredient that could change while the cache still claims a pass.
- *
- * Reports a reason instead of a key when the install fingerprint cannot be read, which disables the gate.
- */
-export declare function computeCacheKey(options: {
-    anchorDir: string;
-    command: string;
-    commandString: string;
-    env: NodeJS.ProcessEnv;
-    monorepoRoot: string;
-    nmrVersion: string;
-    runtime?: RuntimeIdentity;
-    snapshot: TreeSnapshot;
-}): {
-    ok: true;
-    key: string;
-} | {
-    ok: false;
-    reason: string;
-};
-/**
- * Folds what changes a transcript without changing a conclusion onto the pass key: the channel on which each of
- * the command's output streams ran, and the environment variables through which a tool presents itself.
- *
- * The channel kind keeps a run at a terminal from replaying a piped recording. It is the channel's kind and not
- * whether a terminal is attached: under quiet mode the child writes to pipes at a terminal, and its transcript
- * is reproducible.
- */
-export declare function computeRetentionKey(options: {
-    channels: OutputChannels;
-    env: NodeJS.ProcessEnv;
-    passKey: string;
-}): string;
 /** Renders a snapshot for the environment of every process below this one. */
 export declare function encodeTreeSnapshot(snapshot: TreeSnapshot): string;
-/**
- * Names a covered package whose output differs between two observations of it, or `undefined` when every
- * package agrees. A package that has appeared or disappeared between them counts as a disagreement, because
- * the output that the earlier observation describes is not the output that the later one found.
- */
-export declare function findStaleBuildOutput(earlierDigests: Record<string, string>, laterDigests: Record<string, string>): string | undefined;
 /**
  * Renders the warning for a `--no-cache` that appears after the command name, which makes it an argument to
  * the command rather than a flag to nmr. nmr passes the argument on unchanged, so the warning is the only sign
@@ -169,44 +46,6 @@ export declare function formatMisplacedNoCacheWarning(command: string, style: Ou
  * excluding it here keeps the gate and every reader of its entries in agreement.
  */
 export declare function isCacheableCommand(checkCache: CheckCacheConfig | undefined, command: string): boolean;
-/**
- * Reads the state of the build output that nmr's own build covers. Build output is git-ignored, so the tree hash
- * says nothing about it: a `ci` whose `build` constituent is cached would otherwise skip on a tree whose `dist`
- * had been deleted, or whose `dist` was compiled from a different tree, and hand back a green exit over a
- * repository that cannot run.
- *
- * Because a package whose `build` or `compile` is overridden emits to a location that this function does not
- * know about, it is left out rather than made a permanent miss.
- */
-export declare function readBuildOutputState(monorepoRoot: string, config: NmrConfig): Promise<BuildOutputState>;
-/**
- * Reads the entry recorded for one command at one scope, or `undefined` when there is none to trust.
- *
- * Retention is vouched for separately from the pass that contains it: an excerpt of a shape that this function
- * cannot read is dropped, leaving a pass that skips cleanly and reports its verdict alone.
- */
-export declare function readCheckCacheEntry(options: {
-    anchorDir: string;
-    command: string;
-    monorepoRoot: string;
-}): Promise<CheckCacheEntry | undefined>;
-/**
- * Reads the whole output that one recorded pass retained, or `undefined` when it retained none.
- *
- * Held to nothing on its own: the entry beside it says which tree the bytes describe, and a caller
- * that has not matched the entry's key is reading a transcript of some other tree.
- */
-export declare function readTranscript(ref: EntryRef): Promise<string | undefined>;
-/**
- * Makes the transcript beside one entry be exactly what this pass retained, removing what an earlier pass
- * left when this one retained nothing.
- *
- * A composite retains nothing of its own, so without the removal a leaf's transcript would remain beside an
- * entry that never produced it, and `--log` would date another run's bytes by this one's instant.
- */
-export declare function recordTranscript(ref: EntryRef, transcript: string | undefined): Promise<void>;
-/** Removes every recorded pass for a monorepo, or for a standalone package outside one. */
-export declare function removeCheckCache(scopeDir: string): Promise<void>;
 /**
  * Merges a repo's `checkCache` configuration into the default set: `extraCommands` adds to the defaults, and
  * `excludeCommands` removes a command whose chain does more than report an exit status.
@@ -217,7 +56,7 @@ export declare function resolveCacheableCommands(checkCache: CheckCacheConfig |
  * down, and otherwise a fresh one, because the run starts at this invocation.
  *
  * Unbounded, whereas the tree snapshot is bounded by a HEAD comparison: a process that outlives its run hands a
- * stale identity to the invocations that it later makes, and the tree hash keeps that harmless, because every
+ * stale identity to the invocations that it later makes, and the tree id keeps that harmless, because every
  * constituent entry is held to it before its excerpt joins an assembly.
  */
 export declare function resolveRunId(env: NodeJS.ProcessEnv): string;
@@ -240,13 +79,6 @@ export declare function resolveTreeSnapshot(options: {
     ok: false;
     reason: string;
 };
-/** Records a pass, replacing whatever this command last recorded at this scope. */
-export declare function writeCheckCacheEntry(options: {
-    anchorDir: string;
-    command: string;
-    entry: CheckCacheEntry;
-    monorepoRoot: string;
-}): Promise<void>;
 /**
  * Writes a note explaining a gate decision, but only when `NMR_DEBUG=1`. The gate is silent by default: a
  * reason to run is not news, and a line per invocation explaining why nothing was skipped would bury the

package/dist/esm/check-cache.js

@@ -1,22 +1,7 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { readFileSync, realpathSync } from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { hashWorkingTree, readCacheEntry, readHeadSha, readJsonCacheEntry, removeCacheDir, removeCacheEntry, resolveCacheEntryPath, STATUS_GLYPHS, writeCacheEntry, } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
-import { hasBuildOutput, readBuildDigest } from "./commands/build-output.js";
-import { loadWorkspaceConfig } from "./config.js";
+import { randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { hashWorkingTree, readHeadSha, STATUS_GLYPHS } from '@williamthorsen/nmr-core';
 import { isHookName } from "./helpers/hook-name.js";
-import { isObject, isStringRecord } from "./helpers/type-guards.js";
-import { getDefaultWorkspaceScripts } from "./resolve-scripts.js";
-import { buildWorkspaceRegistry, resolveScript } from "./resolver.js";
-import { renderChain } from "./steps.js";
-import { getWorkspacePackageDirs } from "./workspace.js";
-export const CURRENT_RUNTIME = {
-    arch: process.arch,
-    nodeVersion: process.version,
-    platform: process.platform,
-};
 export const DEBUG_ENV_VAR = 'NMR_DEBUG';
 export const DEFAULT_CACHEABLE_COMMANDS = [
     'check',
@@ -40,72 +25,11 @@ export const DEFAULT_CACHEABLE_COMMANDS = [
     'typecheck',
 ];
 export const NO_CACHE_ENV_VAR = 'NMR_NO_CACHE';
+export const PASS_MANIFEST_DIR_ENV_VAR = 'NMR_PASS_MANIFEST_DIR';
 export const RUN_ID_ENV_VAR = 'NMR_RUN_ID';
 export const TREE_SNAPSHOT_ENV_VAR = 'NMR_TREE_SNAPSHOT';
-const BUILT_IN_COMPILE = 'nmr-compile';
-const CACHE_TOOL = 'nmr-check';
-const INSTALL_FINGERPRINT_FILES = [
-    path.join('node_modules', '.modules.yaml'),
-    path.join('node_modules', '.pnpm', 'lock.yaml'),
-];
-const KEY_FORMAT = 'nmr-check-cache-v1';
-const KEYED_ENV_VARS = ['LANG', 'LC_ALL', 'NODE_OPTIONS', 'TZ'];
-const RETENTION_KEY_FORMAT = 'nmr-retention-v1';
-const RETENTION_KEYED_ENV_VARS = ['CI', 'COLUMNS', 'FORCE_COLOR', 'NO_COLOR', 'TERM'];
-const UNSAFE_SLUG_CHARACTERS = /[^\w.-]+/g;
-export async function certifyRetention(options) {
-    const { entry, runId } = options;
-    if (entry.retention === undefined || entry.retention.runId === runId) {
-        return;
-    }
-    try {
-        await writeCheckCacheEntry({
-            anchorDir: options.anchorDir,
-            command: options.command,
-            monorepoRoot: options.monorepoRoot,
-            entry: { ...entry, retention: { ...entry.retention, runId } },
-        });
-    }
-    catch (error) {
-        writeDebugNote(`could not certify ${options.command}: ${describeError(error)}`, options.env, options.stderr);
-    }
-}
-export function computeCacheKey(options) {
-    const fingerprint = resolveInstallFingerprint(options.monorepoRoot);
-    if (!fingerprint.ok) {
-        return fingerprint;
-    }
-    const runtime = options.runtime ?? CURRENT_RUNTIME;
-    const scope = path.relative(options.monorepoRoot, options.anchorDir);
-    const parts = [
-        KEY_FORMAT,
-        options.snapshot.hash,
-        scope === '' ? '.' : scope,
-        options.command,
-        options.commandString,
-        options.nmrVersion,
-        runtime.nodeVersion,
-        runtime.platform,
-        runtime.arch,
-        fingerprint.fingerprint,
-    ];
-    return { ok: true, key: digestParts([...parts, ...composeEnvParts(KEYED_ENV_VARS, options.env)]) };
-}
-export function computeRetentionKey(options) {
-    const parts = [
-        RETENTION_KEY_FORMAT,
-        options.passKey,
-        describeChannel(options.channels.stdout),
-        describeChannel(options.channels.stderr),
-    ];
-    return digestParts([...parts, ...composeEnvParts(RETENTION_KEYED_ENV_VARS, options.env)]);
-}
 export function encodeTreeSnapshot(snapshot) {
-    return `${snapshot.hash} ${snapshot.headSha}`;
-}
-export function findStaleBuildOutput(earlierDigests, laterDigests) {
-    const names = [...new Set([...Object.keys(earlierDigests), ...Object.keys(laterDigests)])].toSorted();
-    return names.find((name) => earlierDigests[name] !== laterDigests[name]);
+    return `${snapshot.treeId} ${snapshot.headSha}`;
 }
 export function formatMisplacedNoCacheWarning(command, style) {
     return (`${STATUS_GLYPHS[style].warning.text} --no-cache after the command name is passed to \`${command}\`, ` +
@@ -114,57 +38,6 @@ export function formatMisplacedNoCacheWarning(command, style) {
 export function isCacheableCommand(checkCache, command) {
     return !isHookName(command) && checkCache?.enabled !== false && resolveCacheableCommands(checkCache).has(command);
 }
-export async function readBuildOutputState(monorepoRoot, config) {
-    const state = { missingPackages: [], digests: {} };
-    let packageDirs;
-    try {
-        packageDirs = getWorkspacePackageDirs(monorepoRoot);
-    }
-    catch {
-        return state;
-    }
-    const registry = buildWorkspaceRegistry(config);
-    if (JSON.stringify(registry['build']) !== JSON.stringify(getDefaultWorkspaceScripts()['build'])) {
-        return state;
-    }
-    for (const packageDir of packageDirs) {
-        if (!isProbeSubject(packageDir, registry)) {
-            continue;
-        }
-        const { build } = await loadWorkspaceConfig(packageDir);
-        const options = build?.extraIgnorePatterns === undefined ? {} : { extraIgnorePatterns: build.extraIgnorePatterns };
-        const name = path.relative(monorepoRoot, packageDir);
-        if (await hasBuildOutput(packageDir, options)) {
-            state.digests[name] = (await readBuildDigest(packageDir)) ?? '';
-        }
-        else {
-            state.missingPackages.push(name);
-        }
-    }
-    return state;
-}
-export async function readCheckCacheEntry(options) {
-    const parsedEntry = await readJsonCacheEntry(resolveEntryPath(options), isParsedCheckCacheEntry);
-    if (parsedEntry === undefined) {
-        return undefined;
-    }
-    const { retention, ...pass } = parsedEntry;
-    return isRetention(retention) ? { ...pass, retention } : pass;
-}
-export async function readTranscript(ref) {
-    return readCacheEntry(resolveEntryPath(ref, '.log'));
-}
-export async function recordTranscript(ref, transcript) {
-    const entryPath = resolveEntryPath(ref, '.log');
-    if (transcript === undefined) {
-        await removeCacheEntry(entryPath);
-        return;
-    }
-    await writeCacheEntry(entryPath, transcript);
-}
-export async function removeCheckCache(scopeDir) {
-    await removeCacheDir({ tool: CACHE_TOOL, scopeDir });
-}
 export function resolveCacheableCommands(checkCache) {
     const commands = new Set([...DEFAULT_CACHEABLE_COMMANDS, ...(checkCache?.extraCommands ?? [])]);
     const excludedCommands = checkCache?.excludeCommands ?? [];
@@ -196,98 +69,20 @@ export function resolveTreeSnapshot(options) {
     if (hashedTree.toplevel !== physicalRoot) {
         return { ok: false, reason: `the monorepo root is not the git toplevel (${hashedTree.toplevel})` };
     }
-    return { ok: true, snapshot: { hash: hashedTree.hash, headSha: hashedTree.headSha } };
-}
-export async function writeCheckCacheEntry(options) {
-    await writeCacheEntry(resolveEntryPath(options), JSON.stringify(options.entry, undefined, 2));
+    return { ok: true, snapshot: { treeId: hashedTree.treeId, headSha: hashedTree.headSha } };
 }
 export function writeDebugNote(message, env, stderr) {
     if (env[DEBUG_ENV_VAR] === '1') {
         stderr.write(`nmr check-cache: ${message}\n`);
     }
 }
-function composeEnvParts(names, env) {
-    return names.flatMap((name) => {
-        const value = env[name];
-        return [name, value === undefined ? 'unset' : 'set', value ?? ''];
-    });
-}
 function decodeTreeSnapshot(encodedSnapshot) {
     if (encodedSnapshot === undefined) {
         return undefined;
     }
-    const [hash, headSha] = encodedSnapshot.split(' ', 2);
-    if (hash === undefined || headSha === undefined || hash === '' || headSha === '') {
+    const [treeId, headSha] = encodedSnapshot.split(' ', 2);
+    if (treeId === undefined || headSha === undefined || treeId === '' || headSha === '') {
         return undefined;
     }
-    return { hash, headSha };
-}
-function describeChannel(channel) {
-    return channel === 'pipe' ? 'pipe' : 'descriptor';
-}
-function digestParts(parts) {
-    const hash = createHash('sha256');
-    for (const part of parts) {
-        hash.update(part);
-        hash.update('\0');
-    }
-    return hash.digest('hex');
-}
-function isParsedCheckCacheEntry(value) {
-    if (!isObject(value)) {
-        return false;
-    }
-    const stringFields = ['key', 'treeHash', 'headSha', 'commandString', 'nmrVersion', 'nodeVersion', 'recordedAt'];
-    if (stringFields.some((field) => typeof value[field] !== 'string')) {
-        return false;
-    }
-    return (typeof value['durationMs'] === 'number' &&
-        Number.isFinite(value['durationMs']) &&
-        !Number.isNaN(Date.parse(String(value['recordedAt']))) &&
-        isStringRecord(value['buildDigests']));
-}
-function isProbeSubject(packageDir, registry) {
-    const build = resolveScript('build', registry, packageDir, false);
-    if (build === undefined || build.origin.tier === 'package') {
-        return false;
-    }
-    const compile = resolveScript('compile', registry, packageDir, false);
-    return compile !== undefined && renderChain(compile.steps) === BUILT_IN_COMPILE;
-}
-function isReplayLine(value) {
-    return (isObject(value) &&
-        typeof value['command'] === 'string' &&
-        typeof value['excerpt'] === 'string' &&
-        typeof value['scope'] === 'string');
-}
-function isRetention(value) {
-    return (isObject(value) &&
-        typeof value['key'] === 'string' &&
-        typeof value['runId'] === 'string' &&
-        Array.isArray(value['replay']) &&
-        value['replay'].every((line) => isReplayLine(line)));
-}
-function resolveEntryPath(options, extension = '.json') {
-    const anchorDir = path.resolve(options.anchorDir);
-    const ref = {
-        tool: CACHE_TOOL,
-        scopeDir: options.monorepoRoot,
-        slug: `${path.basename(anchorDir)}-${options.command.replaceAll(UNSAFE_SLUG_CHARACTERS, '-')}`,
-        extension,
-        discriminators: [anchorDir, options.command],
-    };
-    return resolveCacheEntryPath(ref);
-}
-function resolveInstallFingerprint(monorepoRoot) {
-    const hash = createHash('sha256');
-    for (const relativePath of INSTALL_FINGERPRINT_FILES) {
-        try {
-            hash.update(readFileSync(path.join(monorepoRoot, relativePath)));
-        }
-        catch {
-            return { ok: false, reason: `no install fingerprint: ${relativePath} is unreadable` };
-        }
-        hash.update('\0');
-    }
-    return { ok: true, fingerprint: hash.digest('hex') };
+    return { treeId, headSha };
 }